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

examples/console_discussion.py

@@ -0,0 +1,207 @@
+# 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, LollmsDiscussion, MSG_TYPE, DatabaseManager
+from ascii_colors import ASCIIColors
+from sqlalchemy import Column, String
+
+# --- 1. Define Application-Specific Schema ---
+# We define our custom 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 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="qwen3:4b")
+        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
+
+    # --- 3. Setup Database Manager ---
+    DB_PATH = "sqlite:///research_projects_final.db"
+    ENCRYPTION_KEY = "a-secure-password-for-the-database"
+    
+    try:
+        db_manager = DatabaseManager(
+            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
+
+    # --- 4. Main Application Loop ---
+    # This loop demonstrates the new management features.
+    discussion = None
+    while True:
+        print("\n--- Main Menu ---")
+        if discussion:
+            print(f"Current Project: '{discussion.metadata.get('project_name', discussion.id)}'")
+            print("c. Chat in current project")
+            print("r. Regenerate last AI response (create new branch)")
+        print("l. List all projects")
+        print("s. Search for a project")
+        print("n. Start a new project")
+        print("o. Open an existing project")
+        print("d. Delete a project")
+        print("e. Exit")
+        
+        choice = input("> ").lower()
+
+        if choice == 'c' and discussion:
+            chat_loop(discussion)
+        elif choice == 'r' and discussion:
+            regenerate_response(discussion)
+        elif choice == 'l':
+            list_all_projects(db_manager)
+        elif choice == 's':
+            search_for_project(db_manager)
+        elif choice == 'n':
+            discussion = start_new_project(lc, db_manager)
+        elif choice == 'o':
+            discussion = open_project(lc, db_manager)
+        elif choice == 'd':
+            delete_project(db_manager)
+            if discussion and discussion.id not in [d['id'] for d in db_manager.list_discussions()]:
+                discussion = None # Clear current discussion if it was deleted
+        elif choice == 'e':
+            break
+        else:
+            ASCIIColors.red("Invalid choice.")
+
+    # --- Cleanup ---
+    print("\n--- Demo complete. Cleaning up. ---")
+    if os.path.exists(DB_PATH):
+        os.remove(DB_PATH)
+
+def list_all_projects(db_manager: DatabaseManager):
+    projects = db_manager.list_discussions()
+    if not projects:
+        ASCIIColors.yellow("No projects found.")
+        return
+    print("\n--- All Projects ---")
+    for p in projects:
+        print(f"- ID: {p['id']} | Name: {p.get('project_name', 'N/A')}")
+
+def search_for_project(db_manager: DatabaseManager):
+    term = input("Enter search term for project name: ")
+    projects = db_manager.search_discussions(project_name=term)
+    if not projects:
+        ASCIIColors.yellow(f"No projects found matching '{term}'.")
+        return
+    print(f"\n--- Search Results for '{term}' ---")
+    for p in projects:
+        print(f"- ID: {p['id']} | Name: {p.get('project_name', 'N/A')}")
+
+def start_new_project(lc: LollmsClient, db_manager: DatabaseManager) -> LollmsDiscussion:
+    name = input("Enter new project name: ")
+    if not name:
+        ASCIIColors.red("Project name cannot be empty.")
+        return None
+    discussion = LollmsDiscussion.create_new(
+        lollms_client=lc,
+        db_manager=db_manager,
+        autosave=True, # Recommended for interactive apps
+        project_name=name
+    )
+    discussion.system_prompt = f"This is a research project about {name}."
+    ASCIIColors.green(f"Project '{name}' created successfully.")
+    return discussion
+
+def open_project(lc: LollmsClient, db_manager: DatabaseManager) -> LollmsDiscussion:
+    list_all_projects(db_manager)
+    disc_id = input("Enter project ID to open: ")
+    discussion = db_manager.get_discussion(lollms_client=lc, discussion_id=disc_id, autosave=True)
+    if not discussion:
+        ASCIIColors.red("Project not found.")
+        return None
+    ASCIIColors.green(f"Opened project '{discussion.metadata.get('project_name', discussion.id)}'.")
+    return discussion
+
+def delete_project(db_manager: DatabaseManager):
+    list_all_projects(db_manager)
+    disc_id = input("Enter project ID to DELETE: ")
+    confirm = input(f"Are you sure you want to permanently delete project {disc_id}? (y/N): ")
+    if confirm.lower() == 'y':
+        db_manager.delete_discussion(disc_id)
+        ASCIIColors.green("Project deleted.")
+    else:
+        ASCIIColors.yellow("Deletion cancelled.")
+
+def chat_loop(discussion: LollmsDiscussion):
+    """The interactive chat session for a given discussion."""
+    print("\n--- Entering Chat ---")
+    
+    # Display the current branch history when entering the chat.
+    current_branch = discussion.get_branch(discussion.active_branch_id)
+    if current_branch:
+        ASCIIColors.cyan("--- Current Conversation History ---")
+        for msg in current_branch:
+            sender = msg['sender']
+            if sender == 'user':
+                ASCIIColors.green(f"You: {msg['content']}")
+            else:
+                ASCIIColors.blue(f"AI: {msg['content']}")
+        ASCIIColors.cyan("----------------------------------")
+
+    print("Type your message, or /back, /toggle_thoughts")
+    show_thoughts_flag = False
+    
+    def stream_to_console(token: str, msg_type: MSG_TYPE):
+        if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
+            print(token, end="", flush=True)
+        elif msg_type == MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK:
+            ASCIIColors.magenta(token, end="", flush=True)
+        return True
+
+    while True:
+        user_input = input("\nYou > ")
+        if user_input.lower() == '/back': break
+        
+        if user_input.lower() == '/toggle_thoughts':
+            show_thoughts_flag = not show_thoughts_flag
+            ASCIIColors.yellow(f"\n[{'ON' if show_thoughts_flag else 'OFF'}] Thoughts are now displayed.")
+            continue
+
+        print("AI > ", end="", flush=True)
+        discussion.chat(
+            user_input, 
+            show_thoughts=show_thoughts_flag,
+            streaming_callback=stream_to_console
+        )
+        print()
+
+def regenerate_response(discussion: LollmsDiscussion):
+    """Demonstrates creating a new branch by regenerating."""
+    try:
+        ASCIIColors.yellow("\nRegenerating last AI response...")
+        print("New AI > ", end="", flush=True)
+        def stream_to_console(token: str, msg_type: MSG_TYPE):
+            print(token, end="", flush=True)
+            return True
+        discussion.regenerate_branch(show_thoughts=True, streaming_callback=stream_to_console)
+        print()
+        ASCIIColors.green("New branch created.")
+    except ValueError as e:
+        ASCIIColors.red(f"Could not regenerate: {e}")
+
+if __name__ == "__main__":
+    main()

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, DatabaseManager
+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 = DatabaseManager(
+        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 DatabaseManager, 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 DatabaseManager with our schema and encryption key.
+        db_manager = DatabaseManager(
+            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,13 @@
 # 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, DatabaseManager
 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.21.0" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [
@@ -15,7 +15,7 @@ __all__ = [
     "ELF_COMPLETION_FORMAT",
     "MSG_TYPE",
     "LollmsDiscussion",
-    "LollmsMessage",
+    "DatabaseManager",
     "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