lollms-client 0.32.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

examples/mcp_examples/run_remote_mcp_example_v2.py

@@ -1,290 +0,0 @@
-# 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
-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.
-# 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 ---
-
-    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_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
-    )
-    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()

examples/mcp_examples/run_standard_mcp_example.py

@@ -1,204 +0,0 @@
-# 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
-# --- 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.")
-
-@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="stdio")
-"""
-
-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.")
-
-@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="stdio")
-"""
-
-
-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)
-
-    # MCP Binding Configuration (for StandardMCPBinding)
-    mcp_config = {
-        "initial_servers": {
-            "time_machine": {
-                "command": [sys.executable, str(time_server_script_path.resolve())],
-            },
-            "calc_unit": {
-                "command": [sys.executable, str(calculator_server_script_path.resolve())]
-            }
-        }
-    }
-    ASCIIColors.magenta("\n1. Initializing LollmsClient...")
-    try:
-        client = LollmsClient(
-            binding_name="ollama", # Use the dummy LLM binding
-            model_name="mistral-nemo:latest",
-            mcp_binding_name="standard_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()

examples/simple_text_gen_test.py

@@ -1,173 +0,0 @@
-from lollms_client import LollmsClient
-from lollms_client.lollms_types import MSG_TYPE # For callback signature
-from ascii_colors import ASCIIColors, trace_exception
-
-# --- Configuration ---
-# Choose your LLM binding and parameters here
-# Option 1: Default LOLLMS server binding
-BINDING_NAME = "lollms"
-HOST_ADDRESS = "http://localhost:9600"
-MODEL_NAME = None # Server will use its default or last loaded model
-
-# Option 2: Ollama binding
-#ensure you have the right models
-#BINDING_NAME = "ollama"
-#HOST_ADDRESS = "http://localhost:11434" # Default Ollama host
-#MODEL_NAME = "mistral:latest" # Or "llama3:latest", "phi3:latest", etc. - ensure it's pulled in Ollama
-
-# Option 3: OpenAI binding (requires OPENAI_API_KEY environment variable or service_key)
-# BINDING_NAME = "openai"
-# HOST_ADDRESS = None # Defaults to OpenAI API
-# MODEL_NAME = "gpt-3.5-turbo"
-# SERVICE_KEY = "" # Optional, can use env var
-
-# --- Callback for streaming ---
-def simple_streaming_callback(chunk: str, msg_type: MSG_TYPE, params=None, metadata=None) -> bool:
-    """
-    Simple callback function to print streamed text chunks.
-    """
-    if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
-        print(chunk, end="", flush=True)
-    elif msg_type == MSG_TYPE.MSG_TYPE_EXCEPTION:
-        ASCIIColors.error(f"\nStreaming Error: {chunk}")
-    # Return True to continue streaming, False to stop
-    return True
-
-def test_text_generation():
-    ASCIIColors.cyan(f"\n--- Testing Text Generation with '{BINDING_NAME}' binding ---")
-    ASCIIColors.cyan(f"Host: {HOST_ADDRESS or 'Default'}, Model: {MODEL_NAME or 'Default'}")
-
-    try:
-        # Initialize LollmsClient
-        lc_params = {
-            "binding_name": BINDING_NAME,
-            "host_address": HOST_ADDRESS,
-            "model_name": MODEL_NAME,
-            #"service_key": SERVICE_KEY, # Uncomment for OpenAI if needed
-        }
-        # Remove None host_address for bindings that have internal defaults (like OpenAI)
-        if lc_params["host_address"] is None and BINDING_NAME in ["openai"]:
-             del lc_params["host_address"]
-
-
-        lc = LollmsClient(**lc_params)
-
-        # 1. Test basic non-streaming generation
-        ASCIIColors.magenta("\n1. Basic Non-Streaming Generation:")
-        prompt_non_stream = "Tell me a short joke about a programmer."
-        ASCIIColors.yellow(f"Prompt: {prompt_non_stream}")
-        response_non_stream = lc.generate_text(
-            prompt=prompt_non_stream,
-            stream=False,
-            temperature=0.7,
-            n_predict=100 # Max tokens for the joke
-        )
-
-        if isinstance(response_non_stream, str):
-            ASCIIColors.green("Response:")
-            print(response_non_stream)
-        elif isinstance(response_non_stream, dict) and "error" in response_non_stream:
-            ASCIIColors.error(f"Error in non-streaming generation: {response_non_stream['error']}")
-        else:
-            ASCIIColors.warning(f"Unexpected response format: {response_non_stream}")
-
-        # 2. Test streaming generation
-        ASCIIColors.magenta("\n\n2. Streaming Generation:")
-        prompt_stream = "Explain the concept of recursion in one sentence."
-        ASCIIColors.yellow(f"Prompt: {prompt_stream}")
-        ASCIIColors.green("Response (streaming):")
-        response_stream = lc.generate_text(
-            prompt=prompt_stream,
-            stream=True,
-            streaming_callback=simple_streaming_callback,
-            temperature=0.5,
-            n_predict=150
-        )
-        print() # Newline after streaming
-
-        # The 'response_stream' variable will contain the full concatenated text if streaming_callback returns True throughout
-        # or an error dictionary if generation failed.
-        if isinstance(response_stream, str):
-            ASCIIColors.cyan(f"\n(Full streamed text was: {response_stream[:100]}...)") # Show a snippet of full text
-        elif isinstance(response_stream, dict) and "error" in response_stream:
-            ASCIIColors.error(f"Error in streaming generation: {response_stream['error']}")
-
-        print("Testing embedding")
-        emb = lc.embed("hello")
-        print(emb)
-
-        # else: if callback returns False early, response_stream might be partial.
-        nb_tokens = lc.count_tokens("")
-        ASCIIColors.yellow("Number of tokens of : Testing count of tokens\n"+f"{nb_tokens}")
-
-        # 3. Test generation with a specific model (if applicable and different from default)
-        #    This tests the switch_model or model loading mechanism of the binding.
-        #    For 'lollms' binding, this would set the model on the server.
-        #    For 'ollama' or 'openai', it means the next generate_text will use this model.
-        ASCIIColors.magenta("\n\n3. List Available Models & Generate with Specific Model:")
-        available_models = lc.listModels()
-        if isinstance(available_models, list) and available_models:
-            ASCIIColors.green("Available models:")
-            for i, model_info in enumerate(available_models[:5]): # Print first 5
-                model_id = model_info.get('model_name', model_info.get('id', str(model_info)))
-                print(f"  - {model_id}")
-
-            # Try to use the first available model (or a known one if list is too generic)
-            target_model = None
-            if BINDING_NAME == "ollama":
-                # For Ollama, try using a different small model if available, or the same one
-                if "phi3:latest" in [m.get('name') for m in available_models if isinstance(m, dict)]:
-                    target_model = "phi3:latest"
-                elif available_models: # Fallback to first model in list if phi3 not present
-                     first_model_entry = available_models[0]
-                     target_model = first_model_entry.get('name', first_model_entry.get('model_name'))
-
-
-            elif BINDING_NAME == "lollms":
-                # For lollms, this would typically be a path or server-recognized name
-                # This part is harder to make generic without knowing server's models
-                ASCIIColors.yellow("For 'lollms' binding, ensure the target model is known to the server.")
-                if available_models and isinstance(available_models[0], str): # e.g. gptq model paths
-                    target_model = available_models[0]
-
-
-            if target_model and target_model != lc.binding.model_name: # Only if different and valid
-                ASCIIColors.info(f"\nSwitching to model (or using for next gen): {target_model}")
-                # For bindings like ollama/openai, setting model_name on binding directly works.
-                # For 'lollms' server binding, LollmsClient doesn't have a direct 'switch_model_on_server'
-                # but setting lc.binding.model_name will make the next generate_text request it.
-                lc.binding.model_name = target_model # Update the binding's current model_name
-
-                prompt_specific_model = f"What is the main capability of the {target_model.split(':')[0]} language model?"
-                ASCIIColors.yellow(f"Prompt (for {target_model}): {prompt_specific_model}")
-                ASCIIColors.green("Response:")
-                response_specific = lc.generate_text(
-                    prompt=prompt_specific_model,
-                    stream=True, # Keep it streaming for responsiveness
-                    streaming_callback=simple_streaming_callback,
-                    n_predict=200
-                )
-                print()
-            elif target_model == lc.binding.model_name:
-                ASCIIColors.yellow(f"Target model '{target_model}' is already the current model. Skipping specific model test.")
-            else:
-                ASCIIColors.yellow("Could not determine a different target model from the list to test specific model generation.")
-
-        elif isinstance(available_models, dict) and "error" in available_models:
-            ASCIIColors.error(f"Error listing models: {available_models['error']}")
-        else:
-            ASCIIColors.yellow("No models listed by the binding or format not recognized.")
-
-
-    except ValueError as ve:
-        ASCIIColors.error(f"Initialization Error: {ve}")
-        trace_exception(ve)
-    except RuntimeError as re:
-        ASCIIColors.error(f"Runtime Error (binding likely not initialized): {re}")
-        trace_exception(re)
-    except Exception as e:
-        ASCIIColors.error(f"An unexpected error occurred: {e}")
-        trace_exception(e)
-
-if __name__ == "__main__":
-    test_text_generation()