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

examples/gradio_lollms_chat.py

@@ -0,0 +1,259 @@
+# research_app_final.py
+
+import os
+import json
+import shutil
+import gradio as gr
+from pathlib import Path
+# Use the correct, specified import style
+from lollms_client import LollmsClient, LollmsDiscussion, MSG_TYPE, LollmsDataManager
+from ascii_colors import ASCIIColors
+from sqlalchemy import Column, String
+
+# --- 1. Define Application-Specific Schema ---
+# This allows applications to store and query their own metadata in the database.
+class ResearchDiscussionMixin:
+    project_name = Column(String(100), index=True, nullable=False)
+
+class ResearchMessageMixin:
+    pass
+
+# --- 2. Global Setup: Client and Database ---
+# These are initialized once and used throughout the app's lifecycle.
+try:
+    lc = LollmsClient("ollama", model_name="mistral-nemo:latest")
+    db_manager = LollmsDataManager(
+        db_path="sqlite:///research_projects_gradio.db",
+        discussion_mixin=ResearchDiscussionMixin,
+        message_mixin=ResearchMessageMixin,
+        encryption_key="a-super-secret-key-for-the-gradio-app"
+    )
+    print("✅ Client and Database initialized successfully.")
+except Exception as e:
+    print(f"❌ FATAL: Could not initialize services. Is Ollama running? Error: {e}")
+    lc = None
+    db_manager = None
+
+# --- 3. UI Helper Functions ---
+# These functions connect the Gradio UI to our discussion library's backend logic.
+
+def _get_discussion_list():
+    """Helper to fetch and format the list of discussions for the dropdown."""
+    if not db_manager: return []
+    discussions = db_manager.list_discussions()
+    return [(d.get('project_name', d['id']), d['id']) for d in discussions]
+
+def _format_chatbot_history(discussion: LollmsDiscussion):
+    """Converts a discussion's active branch into Gradio's chatbot format."""
+    history = []
+    if not discussion: return history
+    
+    branch = discussion.get_branch(discussion.active_branch_id)
+    # This robust loop correctly pairs user and AI messages.
+    i = 0
+    while i < len(branch):
+        if branch[i]['sender_type'] == 'user':
+            user_msg = branch[i]['content']
+            if i + 1 < len(branch) and branch[i+1]['sender_type'] == 'assistant':
+                ai_msg = branch[i+1]['content']
+                history.append((user_msg, ai_msg))
+                i += 2
+            else:
+                history.append((user_msg, None))
+                i += 1
+        else:
+            ai_msg = branch[i]['content']
+            history.append((None, ai_msg))
+            i += 1
+    return history
+
+# --- 4. Gradio UI Event Handler Functions ---
+
+def handle_new_discussion(name: str):
+    """Called when the 'New Project' button is clicked."""
+    if not name.strip():
+        gr.Warning("Project name cannot be empty.")
+        return gr.Dropdown(choices=_get_discussion_list()), None, []
+    
+    discussion = LollmsDiscussion.create_new(
+        lollms_client=lc,
+        db_manager=db_manager,
+        project_name=name.strip(),
+        autosave=True
+    )
+    discussion.set_system_prompt(f"This is a research project about {name.strip()}. Be helpful and concise, but use <think> tags to outline your process before answering.")
+    discussion.set_participants({"user":"user", "assistant":"assistant"})
+    
+    gr.Info(f"Project '{name.strip()}' created!")
+    
+    return gr.Dropdown(choices=_get_discussion_list(), value=discussion.id), discussion.id, []
+
+def handle_load_discussion(discussion_id: str):
+    """Called when a discussion is selected from the dropdown."""
+    if not discussion_id:
+        return None, []
+    
+    discussion = db_manager.get_discussion(lollms_client=lc, discussion_id=discussion_id)
+    chatbot_history = _format_chatbot_history(discussion)
+    
+    return chatbot_history
+
+def handle_delete_discussion(discussion_id: str):
+    """Called when the 'Delete' button is clicked."""
+    if not discussion_id:
+        gr.Warning("No project selected to delete.")
+        return gr.Dropdown(choices=_get_discussion_list()), None, []
+        
+    db_manager.delete_discussion(discussion_id)
+    gr.Info("Project deleted.")
+    
+    return gr.Dropdown(choices=_get_discussion_list(), value=None), None, []
+
+def handle_chat_submit(user_input: str, chatbot_history: list, discussion_id: str, show_thoughts: bool):
+    """The main chat handler, called on message submit. Uses a generator for streaming."""
+    if not discussion_id:
+        gr.Warning("Please select or create a project first.")
+        return "", chatbot_history
+    if not user_input.strip():
+        return "", chatbot_history
+        
+    discussion = db_manager.get_discussion(lollms_client=lc, discussion_id=discussion_id, autosave=True)
+    
+    chatbot_history.append((user_input, None))
+    yield "", chatbot_history
+    
+    ai_message_buffer = ""
+    
+    def stream_to_chatbot(token: str, msg_type: MSG_TYPE):
+        nonlocal ai_message_buffer
+        if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
+            ai_message_buffer += token
+            chatbot_history[-1] = (user_input, ai_message_buffer)
+        elif msg_type == MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK:
+            thought_html = f"<p style='color:magenta;'><i>{token}</i></p>"
+            chatbot_history[-1] = (user_input, ai_message_buffer + thought_html)
+        return True
+
+    discussion.chat(
+        user_message=user_input,
+        show_thoughts=show_thoughts,
+        streaming_callback=stream_to_chatbot
+    )
+    
+    yield "", chatbot_history
+
+def handle_regenerate(chatbot_history: list, discussion_id: str, show_thoughts: bool):
+    """Called to regenerate the last AI response."""
+    if not discussion_id:
+        gr.Warning("Please select a project first.")
+        return chatbot_history
+    if not chatbot_history or chatbot_history[-1][1] is None:
+        gr.Warning("Nothing to regenerate.")
+        return chatbot_history
+
+    discussion = db_manager.get_discussion(lollms_client=lc, discussion_id=discussion_id, autosave=True)
+
+    chatbot_history.pop()
+    user_input_for_ui = chatbot_history[-1][0] if chatbot_history else ""
+    chatbot_history.append((user_input_for_ui, None))
+    yield chatbot_history
+
+    ai_message_buffer = ""
+
+    def stream_to_chatbot(token: str, msg_type: MSG_TYPE):
+        nonlocal ai_message_buffer
+        if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
+            ai_message_buffer += token
+            chatbot_history[-1] = (user_input_for_ui, ai_message_buffer)
+        elif msg_type == MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK:
+            thought_html = f"<p style='color:magenta;'><i>{token}</i></p>"
+            chatbot_history[-1] = (user_input_for_ui, ai_message_buffer + thought_html)
+        return True
+
+    discussion.regenerate_branch(
+        show_thoughts=show_thoughts,
+        streaming_callback=stream_to_chatbot
+    )
+    
+    yield chatbot_history
+
+# --- 5. Build and Launch the Gradio App ---
+with gr.Blocks(theme=gr.themes.Soft(), title="Lollms Discussion Manager") as demo:
+    discussion_id_state = gr.State(None)
+
+    gr.Markdown("# Lollms Discussion Manager")
+    
+    with gr.Row():
+        with gr.Column(scale=1, min_width=300):
+            gr.Markdown("## Projects")
+            discussion_dd = gr.Dropdown(
+                choices=_get_discussion_list(),
+                label="Select Project",
+                interactive=True
+            )
+            with gr.Accordion("Manage Projects", open=False):
+                new_discussion_name = gr.Textbox(label="New Project Name", placeholder="Enter name and press button")
+                with gr.Row():
+                    new_discussion_btn = gr.Button("➕ New")
+                    delete_discussion_btn = gr.Button("❌ Delete")
+            
+            gr.Markdown("---")
+            gr.Markdown("## Options")
+            show_thoughts_check = gr.Checkbox(label="Show AI Thoughts", value=False)
+
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(label="Conversation", height=600, bubble_full_width=False, render_markdown=True)
+            with gr.Row():
+                user_input_tb = gr.Textbox(
+                    label="Your Message",
+                    placeholder="Type your message here...",
+                    scale=5,
+                    autofocus=True
+                )
+                send_btn = gr.Button("✉️ Send", variant="primary", scale=1)
+                regenerate_btn = gr.Button("🔄 Regenerate", scale=1)
+
+    # --- Event Handling: Wiring the UI to the backend functions ---
+
+    new_discussion_btn.click(
+        fn=handle_new_discussion,
+        inputs=[new_discussion_name],
+        outputs=[discussion_dd, discussion_id_state, chatbot]
+    ).then(fn=lambda: "", inputs=None, outputs=[new_discussion_name])
+
+    delete_discussion_btn.click(
+        fn=handle_delete_discussion,
+        inputs=[discussion_id_state],
+        outputs=[discussion_dd, discussion_id_state, chatbot]
+    )
+
+    discussion_dd.change(
+        fn=handle_load_discussion,
+        inputs=[discussion_dd],
+        outputs=[chatbot]
+    ).then(lambda x: x, inputs=[discussion_dd], outputs=[discussion_id_state])
+
+    user_input_tb.submit(
+        fn=handle_chat_submit,
+        inputs=[user_input_tb, chatbot, discussion_id_state, show_thoughts_check],
+        outputs=[user_input_tb, chatbot]
+    )
+    send_btn.click(
+        fn=handle_chat_submit,
+        inputs=[user_input_tb, chatbot, discussion_id_state, show_thoughts_check],
+        outputs=[user_input_tb, chatbot]
+    )
+    regenerate_btn.click(
+        fn=handle_regenerate,
+        inputs=[chatbot, discussion_id_state, show_thoughts_check],
+        outputs=[chatbot]
+    )
+
+if __name__ == "__main__":
+    if lc is None or db_manager is None:
+        print("Could not start Gradio app due to initialization failure.")
+    else:
+        demo.launch()
+        print("\n--- App closed. Cleaning up. ---")
+        if os.path.exists("research_projects_gradio.db"):
+            os.remove("research_projects_gradio.db")

examples/lollms_discussions_test.py

@@ -0,0 +1,155 @@
+# research_app_final.py
+
+import os
+import json
+import shutil
+from pathlib import Path
+# Use the correct, specified import style
+from lollms_client import LollmsClient
+from lollms_client.lollms_discussion import LollmsDataManager, LollmsDiscussion
+from lollms_client.lollms_types import MSG_TYPE
+from sqlalchemy import Column, String
+
+# --- 1. Define Application-Specific Schema ---
+# The developer can define their own fields for the database tables.
+# This allows applications to store and query their own metadata.
+class ResearchDiscussionMixin:
+    # We want each discussion to have a 'project_name' that we can search for.
+    project_name = Column(String(100), index=True, nullable=False)
+
+class ResearchMessageMixin:
+    # This mixin is empty for this example.
+    pass
+
+def setup_migration_dummies(folder: Path):
+    """Creates a dummy JSON file to simulate an old, file-based project structure."""
+    if not folder.exists():
+        folder.mkdir(parents=True, exist_ok=True)
+    
+    # This data structure mimics what the old `to_dict` would have produced.
+    discussion_data = {
+        "id": "old_project_alpha",
+        "metadata": {"project_name": "Project Alpha"},
+        "system_prompt": "This is the system prompt for Alpha.",
+        "created_at": "2023-01-01T12:00:00",
+        "updated_at": "2023-01-01T12:05:00",
+        "messages": [
+            {"id": "msg1", "sender": "user", "sender_type":"user", "content": "What was the first finding?", "created_at": "2023-01-01T12:00:00"},
+            {"id": "msg2", "sender": "assistant", "sender_type":"assistant", "content": "It was about quantum states.", "parent_id": "msg1", "created_at": "2023-01-01T12:05:00"}
+        ]
+    }
+    with open(folder / "project_alpha.json", "w") as f:
+        json.dump(discussion_data, f, indent=2)
+    print(f"Created dummy migration file in '{folder}'.")
+
+def main():
+    # --- 2. Setup: Lollms Client is always needed ---
+    print("--- LOLLMS Research Assistant (Final Version) ---")
+    try:
+        # Instantiate the real LollmsClient to connect to a running model service.
+        # Ensure Ollama is running and has pulled the specified model.
+        lc = LollmsClient("ollama", model_name="mistral-nemo:latest")
+        print("LollmsClient connected successfully to Ollama.")
+    except Exception as e:
+        print(f"\nFATAL: Could not connect to LLM binding. Is Ollama running?\nError: {e}")
+        return
+
+    # --- DEMO 1: In-Memory Mode (Backward Compatibility) ---
+    print("\n--- DEMO 1: In-Memory Discussion ---")
+    
+    # Create an in-memory discussion by NOT passing a db_manager.
+    in_memory_discussion = LollmsDiscussion.create_new(lollms_client=lc)
+    in_memory_discussion.system_prompt = "You are a helpful assistant."
+    print("Created an in-memory discussion.")
+
+    # Interact with it. The state is held entirely in the object.
+    user_input_mem = "Can you remember that my favorite color is blue?"
+    print(f"You > {user_input_mem}")
+    print("AI  > ", end="", flush=True)
+    def stream_to_console(token, msg_type=MSG_TYPE.MSG_TYPE_CHUNK):
+        print(token, end="", flush=True)
+        return True
+    in_memory_discussion.chat(user_input_mem, streaming_callback=stream_to_console)
+    print()
+
+    # Save its state to a JSON file. This now works correctly.
+    file_path = Path("./in_memory_save.json")
+    with open(file_path, "w") as f:
+        json.dump(in_memory_discussion.to_dict(), f, indent=2)
+    print(f"\nIn-memory discussion saved to '{file_path}'.")
+    os.remove(file_path)
+
+    # --- DEMO 2: Database-Backed Mode with Migration ---
+    print("\n--- DEMO 2: Database-Backed Mode ---")
+    DB_PATH = "sqlite:///research_projects_final.db"
+    ENCRYPTION_KEY = "a-secure-password-for-the-database"
+    MIGRATION_FOLDER = Path("./old_discussions")
+    
+    try:
+        # Initialize the LollmsDataManager with our schema and encryption key.
+        db_manager = LollmsDataManager(
+            db_path=DB_PATH,
+            discussion_mixin=ResearchDiscussionMixin,
+            message_mixin=ResearchMessageMixin,
+            encryption_key=ENCRYPTION_KEY
+        )
+        print(f"Database setup complete. Encryption is ENABLED.")
+    except Exception as e:
+        print(f"\nFATAL: Could not initialize database. Error: {e}")
+        return
+
+    # Demonstrate the one-time migration from a folder of JSON files.
+    setup_migration_dummies(MIGRATION_FOLDER)
+    input("\nDummy migration files created. Press Enter to run the migration...")
+    LollmsDiscussion.migrate(lollms_client=lc, db_manager=db_manager, folder_path=MIGRATION_FOLDER)
+    
+    session = db_manager.get_session()
+    migrated_count = session.query(db_manager.DiscussionModel).count()
+    print(f"Verification: Found {migrated_count} discussions in the database after migration.")
+    session.close()
+
+    # --- DEMO 3: Live Chat with a DB-Backed Discussion ---
+    input("\nMigration complete. Press Enter to start a new, database-backed chat session...")
+    
+    # Create a new, database-backed discussion with our custom 'project_name'.
+    discussion = LollmsDiscussion.create_new(
+        lollms_client=lc,
+        db_manager=db_manager,
+        max_context_size=lc.default_ctx_size // 2,
+        autosave=True,
+        project_name="Project Gamma (Live)"
+    )
+    discussion.system_prompt = "You are a helpful assistant for Project Gamma."
+    
+    print(f"\n--- Live Chat for '{discussion.db_discussion.project_name}' ---")
+    print("Type your message, or '/exit', '/export_openai', '/export_ollama' to quit.")
+    
+    while True:
+        user_input = input("\nYou > ")
+        if user_input.lower() == '/exit': break
+        
+        if user_input.lower().startswith('/export'):
+            try:
+                format_type = user_input.split('_')[1] + "_chat"
+                exported_data = discussion.export(format_type)
+                print(f"\n--- Exported for {format_type.split('_')[0].upper()} ---")
+                print(json.dumps(exported_data, indent=2))
+                print("-----------------------------------")
+            except IndexError:
+                print("Invalid export command. Use /export_openai or /export_ollama")
+            continue
+
+        print("AI > ", end="", flush=True)
+        # The same streaming callback works seamlessly.
+        discussion.chat(user_input, streaming_callback=stream_to_console)
+        print()
+
+    # --- Cleanup ---
+    print("\n--- Demo complete. Cleaning up. ---")
+    if os.path.exists(DB_PATH):
+        os.remove(DB_PATH)
+    if MIGRATION_FOLDER.exists():
+        shutil.rmtree(MIGRATION_FOLDER)
+
+if __name__ == "__main__":
+    main()

lollms_client/__init__.py

@@ -1,13 +1,14 @@
 # lollms_client/__init__.py
 from lollms_client.lollms_core import LollmsClient, ELF_COMPLETION_FORMAT
 from lollms_client.lollms_types import MSG_TYPE # Assuming ELF_GENERATION_FORMAT is not directly used by users from here
-from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
+from lollms_client.lollms_discussion import LollmsDiscussion, LollmsDataManager, LollmsMessage
+from lollms_client.lollms_personality import LollmsPersonality
 from lollms_client.lollms_utilities import PromptReshaper # Keep general utilities
 # Import new MCP binding classes
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 
 
-__version__ = "0.20.10" # Updated version
+__version__ = "0.22.0" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [
@@ -16,6 +17,8 @@ __all__ = [
     "MSG_TYPE",
     "LollmsDiscussion",
     "LollmsMessage",
+    "LollmsPersonality",
+    "LollmsDataManager",
     "PromptReshaper",
     "LollmsMCPBinding", # Export LollmsMCPBinding ABC
     "LollmsMCPBindingManager", # Export LollmsMCPBindingManager

lollms_client/llm_bindings/ollama/__init__.py

@@ -449,7 +449,7 @@ class OllamaBinding(LollmsLLMBinding):
         """
         return {
             "name": self.binding_name, # from super class
-            "version": ollama.__version__ if ollama else "unknown", # Ollama library version
+            "version": pm.get_installed_version("ollama") if ollama else "unknown", # Ollama library version
             "host_address": self.host_address,
             "model_name": self.model_name,
             "supports_structured_output": False, # Ollama primarily supports text/chat

lollms_client/lollms_core.py

@@ -76,7 +76,9 @@ class LollmsClient():
                  n_threads: int = 8,
                  streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
                  user_name ="user",
-                 ai_name = "assistant"):
+                 ai_name = "assistant",
+                 **kwargs
+                 ):
         """
         Initialize the LollmsClient with LLM and optional modality bindings.
 
@@ -260,6 +262,81 @@ class LollmsClient():
         self.end_ai_header_id_template =": "
         self.end_ai_message_id_template =""
 
+    # 
+    def update_llm_binding(self, binding_name: str, config: Optional[Dict[str, Any]] = None):
+        """Update the LLM binding with a new configuration."""
+        self.binding = self.binding_manager.create_binding(
+            binding_name=binding_name,
+            host_address=self.host_address,
+            models_path=self.models_path,
+            model_name=self.binding.model_name,  # Keep the same model name
+            service_key=self.service_key,
+            verify_ssl_certificate=self.verify_ssl_certificate,
+            **(config or {})
+        )
+        if self.binding is None:
+            available = self.binding_manager.get_available_bindings()
+            raise ValueError(f"Failed to update LLM binding: {binding_name}. Available: {available}")
+
+    def update_tts_binding(self, binding_name: str, config: Optional[Dict[str, Any]] = None):
+        """Update the TTS binding with a new configuration."""
+        self.tts = self.tts_binding_manager.create_binding(
+            binding_name=binding_name,
+            **(config or {})
+        )
+        if self.tts is None:
+            available = self.tts_binding_manager.get_available_bindings()
+            raise ValueError(f"Failed to update TTS binding: {binding_name}. Available: {available}")
+
+    def update_tti_binding(self, binding_name: str, config: Optional[Dict[str, Any]] = None):
+        """Update the TTI binding with a new configuration."""
+        self.tti = self.tti_binding_manager.create_binding(
+            binding_name=binding_name,
+            **(config or {})
+        )
+        if self.tti is None:
+            available = self.tti_binding_manager.get_available_bindings()
+            raise ValueError(f"Failed to update TTI binding: {binding_name}. Available: {available}")
+
+    def update_stt_binding(self, binding_name: str, config: Optional[Dict[str, Any]] = None):
+        """Update the STT binding with a new configuration."""
+        self.stt = self.stt_binding_manager.create_binding(
+            binding_name=binding_name,
+            **(config or {})
+        )
+        if self.stt is None:
+            available = self.stt_binding_manager.get_available_bindings()
+            raise ValueError(f"Failed to update STT binding: {binding_name}. Available: {available}")
+
+    def update_ttv_binding(self, binding_name: str, config: Optional[Dict[str, Any]] = None):
+        """Update the TTV binding with a new configuration."""
+        self.ttv = self.ttv_binding_manager.create_binding(
+            binding_name=binding_name,
+            **(config or {})
+        )
+        if self.ttv is None:
+            available = self.ttv_binding_manager.get_available_bindings()
+            raise ValueError(f"Failed to update TTV binding: {binding_name}. Available: {available}")
+
+    def update_ttm_binding(self, binding_name: str, config: Optional[Dict[str, Any]] = None):
+        """Update the TTM binding with a new configuration."""
+        self.ttm = self.ttm_binding_manager.create_binding(
+            binding_name=binding_name,
+            **(config or {})
+        )
+        if self.ttm is None:
+            available = self.ttm_binding_manager.get_available_bindings()
+            raise ValueError(f"Failed to update TTM binding: {binding_name}. Available: {available}")
+
+    def update_mcp_binding(self, binding_name: str, config: Optional[Dict[str, Any]] = None):
+        """Update the MCP binding with a new configuration."""
+        self.mcp = self.mcp_binding_manager.create_binding(
+            binding_name=binding_name,
+            **(config or {})
+        )
+        if self.mcp is None:
+            available = self.mcp_binding_manager.get_available_bindings()
+            raise ValueError(f"Failed to update MCP binding: {binding_name}. Available: {available}")
 
     # --- Prompt Formatting Properties ---
     @property
@@ -777,10 +854,17 @@ Don't forget encapsulate the code inside a html code tag. This is mandatory.
             f'"{conversation_context}"'
         )
         initial_plan_gen = self.generate_text(prompt=obj_prompt, system_prompt=objective_extraction_system_prompt, temperature=0.0, stream=False)
+        if type(initial_plan_gen)!=str:
+            if "error" in initial_plan_gen:
+                ASCIIColors.error(initial_plan_gen["error"])
+                raise Exception(initial_plan_gen["error"])
+            else:
+                raise Exception("generate text failed. Make sure you are connected to the binding server if you are using remote one")
         current_plan = self.remove_thinking_blocks(initial_plan_gen).strip()
 
         if streaming_callback:
-            streaming_callback(f"Current plan:\n{current_plan}", MSG_TYPE.MSG_TYPE_STEP_END, {"id": "plan_extraction"}, turn_history)
+            streaming_callback("Building initial plan...", MSG_TYPE.MSG_TYPE_STEP_END, {"id": "plan_extraction"}, turn_history)
+            streaming_callback(f"Current plan:\n{current_plan}", MSG_TYPE.MSG_TYPE_STEP, {"id": "plan"}, turn_history)
         turn_history.append({"type": "initial_plan", "content": current_plan})
         
         tool_calls_made_this_turn = []