lollms-client 0.17.2__py3-none-any.whl → 0.19.1__py3-none-any.whl

lollms_client/mcp_bindings/local_mcp/default_tools/internet_search/internet_search.py

@@ -0,0 +1,107 @@
+from typing import Dict, Any, List
+
+# --- Package Management ---
+_duckduckgo_search_installed = False
+_installation_error_message = ""
+try:
+    import pipmaster as pm
+    pm.ensure_packages(["duckduckgo_search"])
+    from duckduckgo_search import DDGS
+    _duckduckgo_search_installed = True
+except Exception as e:
+    _installation_error_message = str(e)
+    DDGS = None # Ensure DDGS is None if import fails
+# --- End Package Management ---
+
+def execute(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Performs an internet search using DuckDuckGo.
+    """
+    if not _duckduckgo_search_installed:
+        return {
+            "search_results": [],
+            "error": f"Required library 'duckduckgo_search' is not installed or import failed: {_installation_error_message}"
+        }
+
+    query = params.get("query")
+    num_results = params.get("num_results", 5)
+
+    if not query:
+        return {"search_results": [], "error": "'query' parameter is required."}
+    if not isinstance(num_results, int) or num_results <= 0:
+        num_results = 5 # Default to 5 if invalid
+
+    try:
+        search_results_formatted: List[Dict[str, str]] = []
+        # DDGS().text returns a generator, max_results limits it.
+        # Note: The DDGS library might sometimes return fewer results than max_results.
+        with DDGS() as ddgs:
+            results = ddgs.text(keywords=query, max_results=num_results)
+            if results:
+                for r in results:
+                    search_results_formatted.append({
+                        "title": r.get("title", "N/A"),
+                        "link": r.get("href", "#"),
+                        "snippet": r.get("body", "N/A")
+                    })
+            
+        if not search_results_formatted and results is None: # Check if ddgs.text itself returned None
+             return {"search_results": [], "error": "Search returned no results or failed to connect."}
+
+
+        return {"search_results": search_results_formatted, "error": None}
+
+    except Exception as e:
+        # Log the exception for server-side debugging if possible
+        # For now, just return it in the error field.
+        print(f"Error during internet search: {str(e)}") # Basic logging
+        # from ascii_colors import trace_exception (if you want to import it here)
+        # trace_exception(e)
+        return {"search_results": [], "error": f"An unexpected error occurred during search: {str(e)}"}
+
+if __name__ == '__main__':
+    import json
+    print("--- Internet Search Tool Test ---")
+
+    if not _duckduckgo_search_installed:
+        print(f"Cannot run test: duckduckgo_search not installed. Error: {_installation_error_message}")
+    else:
+        # Test 1: Simple search
+        params1 = {"query": "What is the capital of France?", "num_results": 3}
+        result1 = execute(params1)
+        print(f"\nTest 1 Result (Query: '{params1['query']}'):\n{json.dumps(result1, indent=2)}")
+        if result1.get("search_results"):
+            assert len(result1["search_results"]) <= 3
+            assert "error" not in result1 or result1["error"] is None
+        else:
+            print(f"Warning: Test 1 might have failed to retrieve results. Error: {result1.get('error')}")
+
+
+        # Test 2: Search with more results
+        params2 = {"query": "Latest AI breakthroughs", "num_results": 6}
+        result2 = execute(params2)
+        print(f"\nTest 2 Result (Query: '{params2['query']}'):\n{json.dumps(result2, indent=2)}")
+        if result2.get("search_results"):
+            assert len(result2["search_results"]) <= 6
+        else:
+            print(f"Warning: Test 2 might have failed to retrieve results. Error: {result2.get('error')}")
+
+
+        # Test 3: No query
+        params3 = {}
+        result3 = execute(params3)
+        print(f"\nTest 3 Result (No query):\n{json.dumps(result3, indent=2)}")
+        assert result3["error"] is not None
+        assert "query' parameter is required" in result3["error"]
+
+        # Test 4: Invalid num_results
+        params4 = {"query": "python programming", "num_results": -1}
+        result4 = execute(params4) # Should default to 5
+        print(f"\nTest 4 Result (Invalid num_results):\n{json.dumps(result4, indent=2)}")
+        if result4.get("search_results"):
+             assert len(result4["search_results"]) <= 5
+        else:
+            print(f"Warning: Test 4 might have failed to retrieve results. Error: {result4.get('error')}")
+
+
+    print("\n--- Tests Finished ---")

lollms_client/mcp_bindings/local_mcp/default_tools/python_interpreter/python_interpreter.py

@@ -0,0 +1,141 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Dict, Any
+import sys
+import json
+import pipmaster as pm
+pm.ensure_packages(["RestrictedPython"])
+
+import RestrictedPython
+from RestrictedPython import compile_restricted, safe_globals
+from RestrictedPython.PrintCollector import PrintCollector
+
+
+def execute(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Executes a snippet of Python code in a restricted environment.
+    """
+    code = params.get("code")
+    timeout_seconds = params.get("timeout_seconds", 10)
+
+    if not code:
+        return {
+            "stdout": "",
+            "stderr": "Error: 'code' parameter is required.",
+            "returned_value": None,
+            "execution_status": "error"
+        }
+
+    # For this local tool, we'll use RestrictedPython for a degree of safety.
+    # A more robust solution for untrusted code would involve containers (e.g., Docker)
+    # or a more heavily sandboxed environment. RestrictedPython is not foolproof.
+
+    restricted_globals = dict(safe_globals) # type: ignore
+    restricted_globals['_print_'] = PrintCollector # Capture print statements
+    restricted_globals['_getattr_'] = RestrictedPython.Guards.safer_getattr # Allow safer attribute access
+    # Add more globals if needed, e.g., math module, but be cautious.
+    # restricted_globals['math'] = math
+
+    stdout_capture = ""
+    stderr_capture = ""
+    returned_value_str = None
+    status = "error" # Default to error
+
+    try:
+        # Compile the code in restricted mode
+        # Adding "<string>" as the filename for tracebacks
+        byte_code = compile_restricted(code, filename='<inline_script>', mode='exec')
+        
+        # Prepare a dictionary for local variables, including the print collector
+        local_vars = {} 
+        
+        # Execute the compiled code
+        # Note: RestrictedPython's exec doesn't directly support timeout.
+        # A more complex setup with threading or multiprocessing would be needed for true timeout.
+        # For simplicity, this example doesn't implement a hard timeout for RestrictedPython's exec.
+        # The timeout_seconds param is more of a hint for now or for alternative execution methods.
+
+        exec(byte_code, restricted_globals, local_vars)
+        
+        stdout_capture = restricted_globals['_print']() # Get captured prints
+        # RestrictedPython itself doesn't easily separate stdout/stderr from exec.
+        # Errors during compilation or guarded execution will raise exceptions.
+
+        # Try to get a returned value if the script used 'return' (not typical for 'exec' mode)
+        # or if a specific variable was set to indicate a return.
+        # For this example, we won't try to capture implicit returns from 'exec'.
+        # If the executed code sets a variable like `result = ...`, it would be in `local_vars`.
+        # We'll consider `returned_value` as None for simplicity with 'exec'.
+
+        status = "success"
+
+    except SyntaxError as se:
+        stderr_capture = f"SyntaxError: {se}"
+        status = "error"
+    except RestrictedPython.Guards. इलाकोंOnlyĐiPythonGuardViolation as rpe: # Common RestrictedPython error
+        stderr_capture = f"RestrictedPythonError: {rpe}"
+        status = "error"
+    except NameError as ne: # Undeclared variable
+        stderr_capture = f"NameError: {ne}"
+        status = "error"
+    except TypeError as te:
+        stderr_capture = f"TypeError: {te}"
+        status = "error"
+    except Exception as e:
+        stderr_capture = f"Execution Error: {type(e).__name__}: {e}"
+        status = "error"
+        trace_exception(e) # For more detailed logging if needed
+
+    return {
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "returned_value": returned_value_str, # Typically None with exec
+        "execution_status": status
+    }
+
+
+if __name__ == '__main__':
+    # Example Tests
+    print("--- Python Interpreter Tool Test ---")
+
+    # Test 1: Simple print
+    params1 = {"code": "print('Hello from restricted Python!')\nx = 10 + 5\nprint(f'Result is {x}')"}
+    result1 = execute(params1)
+    print(f"\nTest 1 Result:\n{json.dumps(result1, indent=2)}")
+    assert result1["execution_status"] == "success"
+    assert "Hello from restricted Python!" in result1["stdout"]
+    assert "Result is 15" in result1["stdout"]
+
+    # Test 2: Code with an error (e.g., trying to access restricted features)
+    params2 = {"code": "import os\nprint(os.getcwd())"} # os is usually restricted
+    result2 = execute(params2)
+    print(f"\nTest 2 Result (expected error):\n{json.dumps(result2, indent=2)}")
+    assert result2["execution_status"] == "error"
+    assert "RestrictedPythonError" in result2["stderr"] or "NameError" in result2["stderr"] # Depending on how os import fails
+
+    # Test 3: Syntax error
+    params3 = {"code": "print('Hello without closing quote"}
+    result3 = execute(params3)
+    print(f"\nTest 3 Result (syntax error):\n{json.dumps(result3, indent=2)}")
+    assert result3["execution_status"] == "error"
+    assert "SyntaxError" in result3["stderr"]
+    
+    # Test 4: No code
+    params4 = {"code": ""}
+    result4 = execute(params4) # Should succeed with empty output or be handled if empty code is invalid.
+                               # Current RestrictedPython might raise error on empty.
+    print(f"\nTest 4 Result (empty code):\n{json.dumps(result4, indent=2)}")    
+    # Depending on compile_restricted behavior for empty string, this might be success or error.
+    # It seems compile_restricted can handle empty strings.
+    assert result4["execution_status"] == "success" 
+    assert result4["stdout"] == ""
+
+    # Test 5: Attempting a disallowed attribute
+    params5 = {"code": "x = ().__class__"} # Example of trying to access something disallowed
+    result5 = execute(params5)
+    print(f"\nTest 5 Result (disallowed attribute):\n{json.dumps(result5, indent=2)}")
+    assert result5["execution_status"] == "error"
+    assert "RestrictedPythonError" in result5["stderr"]
+    
+    print("\n--- Tests Finished ---")

lollms_client/tti_bindings/dalle/__init__.py

@@ -152,7 +152,8 @@ class DalleTTIBinding_Impl(LollmsTTIBinding):
         # Format size string and validate against the active model for this generation
         size_str = f"{width}x{height}"
         if size_str not in model_props["sizes"]:
-            raise ValueError(f"Unsupported size '{size_str}' for model '{active_model_name}'. Supported sizes: {model_props['sizes']}. Adjust width/height for this model.")
+            ASCIIColors.warning(f"Unsupported size '{size_str}' for model '{active_model_name}'. Supported sizes: {model_props['sizes']}. Adjust width/height for this model.")
+            size_str = model_props["sizes"][0]
 
         # Handle prompt and negative prompt based on the active model
         final_prompt = prompt

{lollms_client-0.17.2.dist-info → lollms_client-0.19.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.17.2
+Version: 0.19.1
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License
@@ -39,7 +39,7 @@ Dynamic: license-file
 [![GitHub stars](https://img.shields.io/github/stars/ParisNeo/lollms_client.svg?style=social&label=Star&maxAge=2592000)](https://github.com/ParisNeo/lollms_client/stargazers/)
 [![GitHub issues](https://img.shields.io/github/issues/ParisNeo/lollms_client.svg)](https://github.com/ParisNeo/lollms_client/issues)
 
-**`lollms_client`** is a powerful and flexible Python library designed to simplify interactions with the **LoLLMs (Lord of Large Language Models)** ecosystem and various other Large Language Model (LLM) backends. It provides a unified API for text generation, multimodal operations (text-to-image, text-to-speech, etc.), function calling, and advanced AI-driven tasks.
+**`lollms_client`** is a powerful and flexible Python library designed to simplify interactions with the **LoLLMs (Lord of Large Language Models)** ecosystem and various other Large Language Model (LLM) backends. It provides a unified API for text generation, multimodal operations (text-to-image, text-to-speech, etc.), and robust function calling through the Model Context Protocol (MCP).
 
 Whether you're connecting to a remote LoLLMs server, an Ollama instance, the OpenAI API, or running models locally using GGUF (via `llama-cpp-python` or a managed `llama.cpp` server), Hugging Face Transformers, or vLLM, `lollms-client` offers a consistent and developer-friendly experience.
 
@@ -47,12 +47,12 @@ Whether you're connecting to a remote LoLLMs server, an Ollama instance, the Ope
 
 *   🔌 **Versatile Binding System:** Seamlessly switch between different LLM backends (LoLLMs, Ollama, OpenAI, Llama.cpp, Transformers, vLLM, OpenLLM) without major code changes.
 *   🗣️ **Multimodal Support:** Interact with models capable of processing images and generate various outputs like speech (TTS) and images (TTI).
-*   🚀 **Streaming & Callbacks:** Efficiently handle real-time text generation with customizable callback functions.
-*   🛠️ **Task-Oriented Library:** High-level `TasksLibrary` for common operations like summarization, Q&A, code generation, and structured data extraction.
-*   📞 **Function Calling:** Enable LLMs to invoke your custom Python functions, bridging the gap between language models and external tools or data sources.
+*   🤖 **Function Calling with MCP:** Empowers LLMs to use external tools and functions through the Model Context Protocol (MCP), with built-in support for local Python tool execution via `local_mcp` binding and its default tools (file I/O, internet search, Python interpreter, image generation).
+*   🚀 **Streaming & Callbacks:** Efficiently handle real-time text generation with customizable callback functions, including during MCP interactions.
 *   💬 **Discussion Management:** Utilities to easily manage and format conversation histories for chat applications.
 *   ⚙️ **Configuration Management:** Flexible ways to configure bindings and generation parameters.
-*   🧩 **Extensible:** Designed to easily incorporate new LLM backends and modality services.
+*   🧩 **Extensible:** Designed to easily incorporate new LLM backends and modality services, including custom MCP toolsets.
+*   📝 **High-Level Operations:** Includes convenience methods for complex tasks like sequential summarization and deep text analysis directly within `LollmsClient`.
 
 ## Installation
 
@@ -119,12 +119,61 @@ except Exception as e:
 
 ```
 
+### Function Calling with MCP
+
+`lollms-client` supports robust function calling via the Model Context Protocol (MCP), allowing LLMs to interact with your custom Python tools or pre-defined utilities.
+
+```python
+from lollms_client import LollmsClient, MSG_TYPE
+from ascii_colors import ASCIIColors
+import json # For pretty printing results
+
+# Example callback for MCP streaming
+def mcp_stream_callback(chunk: str, msg_type: MSG_TYPE, metadata: dict = None, turn_history: list = None) -> bool:
+    if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:  ASCIIColors.success(chunk, end="", flush=True) # LLM's final answer or thought process
+    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_START: ASCIIColors.info(f"\n>> MCP Step Start: {metadata.get('tool_name', chunk)}", flush=True)
+    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_END: ASCIIColors.success(f"\n<< MCP Step End: {metadata.get('tool_name', chunk)} -> Result: {json.dumps(metadata.get('result', ''))}", flush=True)
+    elif msg_type == MSG_TYPE.MSG_TYPE_INFO and metadata and metadata.get("type") == "tool_call_request": ASCIIColors.info(f"\nAI requests: {metadata.get('name')}({metadata.get('params')})", flush=True)
+    return True
+
+try:
+    # Initialize LollmsClient with an LLM binding and the local_mcp binding
+    lc = LollmsClient(
+        binding_name="ollama", model_name="mistral", # Example LLM
+        mcp_binding_name="local_mcp" # Enables default tools (file_writer, internet_search, etc.)
+                                     # or custom tools if mcp_binding_config.tools_folder_path is set.
+    )
+
+    user_query = "What were the main AI headlines last week and write a summary to 'ai_news.txt'?"
+    ASCIIColors.blue(f"User Query: {user_query}")
+    ASCIIColors.yellow("AI Processing with MCP (streaming):")
+
+    mcp_result = lc.generate_with_mcp(
+        prompt=user_query,
+        streaming_callback=mcp_stream_callback
+    )
+    print("\n--- End of MCP Interaction ---")
+
+    if mcp_result.get("error"):
+        ASCIIColors.error(f"MCP Error: {mcp_result['error']}")
+    else:
+        ASCIIColors.cyan(f"\nFinal Answer from AI: {mcp_result.get('final_answer', 'N/A')}")
+        ASCIIColors.magenta("\nTool Calls Made:")
+        for tc in mcp_result.get("tool_calls", []):
+            print(f"  - Tool: {tc.get('name')}, Params: {tc.get('params')}, Result (first 50 chars): {str(tc.get('result'))[:50]}...")
+
+except Exception as e:
+    ASCIIColors.error(f"An error occurred in MCP example: {e}")
+    trace_exception(e) # Assuming you have trace_exception utility
+```
+For a comprehensive guide on function calling and setting up tools, please refer to the [Usage Guide (DOC_USE.md)](DOC_USE.md).
+
 ## Documentation
 
 For more in-depth information, please refer to:
 
-*   **[Usage Guide (DOC_USE.md)](DOC_USE.md):** Learn how to use `LollmsClient`, different bindings, modality features, `TasksLibrary`, and `FunctionCalling_Library` with comprehensive examples.
-*   **[Developer Guide (DOC_DEV.md)](DOC_DEV.md):** Understand the architecture, how to create new bindings, and contribute to the library.
+*   **[Usage Guide (DOC_USE.md)](DOC_USE.md):** Learn how to use `LollmsClient`, different bindings, modality features, function calling with MCP, and high-level operations.
+*   **[Developer Guide (DOC_DEV.md)](DOC_DEV.md):** Understand the architecture, how to create new bindings (LLM, modality, MCP), and contribute to the library.
 
 ## Core Concepts
 
@@ -134,8 +183,9 @@ graph LR
 
     subgraph LollmsClient_Core
         LC -- Manages --> LLB[LLM Binding];
-        LC -- Provides Access To --> TL[TasksLibrary];
-        LC -- Provides Access To --> FCL[FunctionCalling_Library];
+        LC -- Manages --> MCPB[MCP Binding];
+        LC -- Orchestrates --> MCP_Interaction[generate_with_mcp];
+        LC -- Provides --> HighLevelOps[High-Level Ops<br>(summarize, deep_analyze etc.)];
         LC -- Provides Access To --> DM[DiscussionManager];
         LC -- Provides Access To --> ModalityBindings[TTS, TTI, STT etc.];
     end
@@ -148,14 +198,19 @@ graph LR
         LLB --> LocalHF[Local HuggingFace<br>(transformers / vLLM)];
     end
 
-    ModalityBindings --> ModalityServices[Modality Services<br>(e.g., LoLLMs Server TTS/TTI)];
+    MCP_Interaction --> MCPB;
+    MCPB --> LocalTools[Local Python Tools<br>(via local_mcp)];
+    MCPB --> RemoteTools[Remote MCP Tool Servers<br>(Future Potential)];
+
+
+    ModalityBindings --> ModalityServices[Modality Services<br>(e.g., LoLLMs Server TTS/TTI, local Bark/XTTS)];
 ```
 
-*   **`LollmsClient`**: The central class for all interactions. It holds the currently active LLM binding and provides access to modality bindings and helper libraries.
+*   **`LollmsClient`**: The central class for all interactions. It holds the currently active LLM binding, an optional MCP binding, and provides access to modality bindings and high-level operations.
 *   **LLM Bindings**: These are plugins that allow `LollmsClient` to communicate with different LLM backends. You choose a binding (e.g., `"ollama"`, `"lollms"`, `"pythonllamacpp"`) when you initialize `LollmsClient`.
+*   **🔧 MCP Bindings**: Enable tool use and function calling. `lollms-client` includes `local_mcp` for executing Python tools. It discovers tools from a specified folder (or uses its default set), each defined by a `.py` script and a `.mcp.json` metadata file.
 *   **Modality Bindings**: Similar to LLM bindings, but for services like Text-to-Speech (`tts`), Text-to-Image (`tti`), etc.
-*   **`TasksLibrary`**: Offers high-level functions for common AI tasks (summarization, Q&A) built on top of `LollmsClient`.
-*   **`FunctionCalling_Library`**: Enables you to define Python functions that the LLM can request to execute, allowing for tool usage.
+*   **High-Level Operations**: Methods directly on `LollmsClient` (e.g., `sequential_summarize`, `deep_analyze`, `generate_code`, `yes_no`) for performing complex, multi-step AI tasks.
 *   **`LollmsDiscussion`**: Helps manage and format conversation histories for chat applications.
 
 ## Examples
@@ -164,8 +219,8 @@ The `examples/` directory in this repository contains a rich set of scripts demo
 *   Basic text generation with different bindings.
 *   Streaming and non-streaming examples.
 *   Multimodal generation (text with images).
-*   Using `TasksLibrary` for summarization and Q&A.
-*   Implementing and using function calls.
+*   Using built-in methods for summarization and Q&A.
+*   Implementing and using function calls with **`generate_with_mcp`** and the `local_mcp` binding (see `examples/function_calling_with_local_custom_mcp.py` and `examples/local_mcp.py`).
 *   Text-to-Speech and Text-to-Image generation.
 
 Explore these examples to see `lollms-client` in action!

{lollms_client-0.17.2.dist-info → lollms_client-0.19.1.dist-info}/RECORD

@@ -1,3 +1,5 @@
+examples/function_calling_with_local_custom_mcp.py,sha256=g6wOFRB8-p9Cv7hKmQaGzPvtMX3H77gas01QVNEOduM,12407
+examples/local_mcp.py,sha256=w40dgayvHYe01yvekEE0LjcbkpwKjWwJ-9v4_wGYsUk,9113
 examples/simple_text_gen_test.py,sha256=RoX9ZKJjGMujeep60wh5WT_GoBn0O9YKJY6WOy-ZmOc,8710
 examples/simple_text_gen_with_image_test.py,sha256=rR1O5Prcb52UHtJ3c6bv7VuTd1cvbkr5aNZU-v-Rs3Y,9263
 examples/text_2_audio.py,sha256=MfL4AH_NNwl6m0I0ywl4BXRZJ0b9Y_9fRqDIe6O-Sbw,3523
@@ -9,23 +11,21 @@ examples/text_gen_system_prompt.py,sha256=jRQeGe1IVu_zRHX09CFiDYi7WrK9Zd5FlMqC_g
 examples/article_summary/article_summary.py,sha256=CR8mCBNcZEVCR-q34uOmrJyMlG-xk4HkMbsV-TOZEnk,1978
 examples/deep_analyze/deep_analyse.py,sha256=fZNmDrfEAuxEAfdbjAgJYIh1k6wbiuZ4RvwHRvtyUs8,971
 examples/deep_analyze/deep_analyze_multiple_files.py,sha256=fOryShA33P4IFxcxUDe-nJ2kW0v9w9yW8KsToS3ETl8,1032
-examples/function_call/functions_call_with images.py,sha256=jrNtTF7lAzad25Ob0Yv4pwLs12HSzDamKKR9ORkNWjc,1888
 examples/generate_and_speak/generate_and_speak.py,sha256=RAlvRwtEKXCh894l9M3iQbADe8CvF5N442jtRurK02I,13908
 examples/generate_game_sfx/generate_game_fx.py,sha256=MgLNGi4hGBRoyr4bqYuCUdCSqd-ldDVfF0VSDUjgzsg,10467
 examples/personality_test/chat_test.py,sha256=o2jlpoddFc-T592iqAiA29xk3x27KsdK5DluqxBwHqw,1417
 examples/personality_test/chat_with_aristotle.py,sha256=4X_fwubMpd0Eq2rCReS2bgVlUoAqJprjkLXk2Jz6pXU,1774
 examples/personality_test/tesks_test.py,sha256=7LIiwrEbva9WWZOLi34fsmCBN__RZbPpxoUOKA_AtYk,1924
 examples/test_local_models/local_chat.py,sha256=slakja2zaHOEAUsn2tn_VmI4kLx6luLBrPqAeaNsix8,456
-lollms_client/__init__.py,sha256=D-gKzzHJSNT09aCJipQi6CUfwb4bSCUwZ-jP2VmalwE,823
+lollms_client/__init__.py,sha256=rbZUoiSGIFLwCBjEUsAC68azS9mIfZ9EXmyasnBDbkY,910
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=fRHdQ0yWAmMuOLZAzDbdlYfCsx0Rb8rQ-RYl_bKgEHk,80049
+lollms_client/lollms_core.py,sha256=psVTrEtHYhjy9h014rHLotBC4Aj72PvG2OV0UAjLcvw,102496
 lollms_client/lollms_discussion.py,sha256=9b83m0D894jwpgssWYTQHbVxp1gJoI-J947Ui_dRXII,2073
-lollms_client/lollms_functions.py,sha256=p8SFtmEPqvVCsIz2fZ5HxyOHaxjrAo5c12uTzJnb6m8,3594
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=bdElz_IBx0zZ-85YTT1fyY_mSoHo46tKIMiHYJlKCkM,9809
+lollms_client/lollms_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
 lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
 lollms_client/lollms_stt_binding.py,sha256=jAUhLouEhh2hmm1bK76ianfw_6B59EHfY3FmLv6DU-g,5111
-lollms_client/lollms_tasks.py,sha256=Tgqces03gPTHFJCcPaeN9vBCsil3SSJX7nQAjCQ2-yg,34393
 lollms_client/lollms_tti_binding.py,sha256=afO0-d-Kqsmh8UHTijTvy6dZAt-XDB6R-IHmdbf-_fs,5928
 lollms_client/lollms_ttm_binding.py,sha256=FjVVSNXOZXK1qvcKEfxdiX6l2b4XdGOSNnZ0utAsbDg,4167
 lollms_client/lollms_tts_binding.py,sha256=5cJYECj8PYLJAyB6SEH7_fhHYK3Om-Y3arkygCnZ24o,4342
@@ -42,12 +42,17 @@ lollms_client/llm_bindings/pythonllamacpp/__init__.py,sha256=7dM42TCGKh0eV0njNL1
 lollms_client/llm_bindings/tensor_rt/__init__.py,sha256=nPaNhGRd-bsG0UlYwcEqjd_UagCMEf5VEbBUW-GWu6A,32203
 lollms_client/llm_bindings/transformers/__init__.py,sha256=9LkqEC5bp1zHgyeGEcPQ3_uqvEAEf_B4p9DztcBaC5w,37211
 lollms_client/llm_bindings/vllm/__init__.py,sha256=2NqeeqYWXNq1aNicdcAwN9DaoL4gq96GZ7hsKErfC6c,32187
+lollms_client/mcp_bindings/local_mcp/__init__.py,sha256=FxS-0PULS3TZScPLDbwHlfyW5joWucmMfn6b9ydyeM0,14341
+lollms_client/mcp_bindings/local_mcp/default_tools/file_writer/file_writer.py,sha256=2pkt1JcEKj61lIA5zuW3s6qkdpQN5rKfooo7bnebx24,3061
+lollms_client/mcp_bindings/local_mcp/default_tools/generate_image_from_prompt/generate_image_from_prompt.py,sha256=THtZsMxNnXZiBdkwoBlfbWY2C5hhDdmPtnM-8cSKN6s,9488
+lollms_client/mcp_bindings/local_mcp/default_tools/internet_search/internet_search.py,sha256=PLC31-D04QKTOTb1uuCHnrAlpysQjsk89yIJngK0VGc,4586
+lollms_client/mcp_bindings/local_mcp/default_tools/python_interpreter/python_interpreter.py,sha256=McDCBVoVrMDYgU7EYtyOY7mCk1uEeTea0PSD69QqDsQ,6228
 lollms_client/stt_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/stt_bindings/lollms/__init__.py,sha256=jBz3285atdPRqQe9ZRrb-AvjqKRB4f8tjLXjma0DLfE,6082
 lollms_client/stt_bindings/whisper/__init__.py,sha256=vrua7fLwDId9_WiH4y2gXOE0hy3Gr2Ig-z5ScIT2bHI,15447
 lollms_client/stt_bindings/whispercpp/__init__.py,sha256=B45lOn5rSoHXJSG9duPzBEPBOoNTrDzpCUdOL8KHaDM,21874
 lollms_client/tti_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client/tti_bindings/dalle/__init__.py,sha256=VuuCWQb6Y3b5-SdU9dMpiKAa2s_4h_B58jE10L8LTak,23577
+lollms_client/tti_bindings/dalle/__init__.py,sha256=V-rODzcwaN9eg0wX8DGOQXXcDtnYYDWYD6t6pFNTo0w,23628
 lollms_client/tti_bindings/diffusers/__init__.py,sha256=Hcu3F3KU8h6b_T4Dpl98OsQrsUoecd_z7xOVIEyYoDc,37679
 lollms_client/tti_bindings/gemini/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/tti_bindings/lollms/__init__.py,sha256=GJShFW6Y8MrfM9PXaPrdAp8OUpD6rraSRFt8ZOnrauo,8735
@@ -62,8 +67,8 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=0IEWG4zH3_sOkSb9WbZzkeV5
 lollms_client/tts_bindings/xtts/__init__.py,sha256=FgcdUH06X6ZR806WQe5ixaYx0QoxtAcOgYo87a2qxYc,18266
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-0.17.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.17.2.dist-info/METADATA,sha256=tAj-msqkBvc8uFcVXq0a-RLD8lP70hAkkrsEUBRLsb0,9798
-lollms_client-0.17.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.17.2.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.17.2.dist-info/RECORD,,
+lollms_client-0.19.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.19.1.dist-info/METADATA,sha256=MKuTL8GsNdArHgSQ_xxhqViSdpEVs0cAK4akk5tNGVM,13374
+lollms_client-0.19.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.19.1.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.19.1.dist-info/RECORD,,

examples/function_call/functions_call_with images.py

@@ -1,52 +0,0 @@
-import cv2
-from lollms_client import LollmsClient, LollmsTTS, TasksLibrary, FunctionCalling_Library
-import random
-
-# Initialize the LollmsClient instance
-lc = LollmsClient()
-tl = TasksLibrary(lc)
-tts = LollmsTTS(lc)
-fcl = FunctionCalling_Library(tl)
-voices = tts.get_voices()
-if voices:
-    # Pick a voice randomly
-    random_voice = random.choice(voices)
-    print(f"Selected voice: {random_voice}")
-
-# File path to save the captured image
-file_path = "captured_image.jpg"
-images = []
-# Capture image from webcam and save it to a file
-def capture_image():
-    cap = cv2.VideoCapture(0)
-    if not cap.isOpened():
-        raise Exception("Could not open webcam")
-
-    ret, frame = cap.read()
-    if not ret:
-        raise Exception("Failed to capture image")
-    images.clear()
-    images.append(file_path)
-    cv2.imwrite(file_path, frame)
-    cap.release()
-    return "Image captured successfully"
-
-
-fcl.register_function("capture_image",capture_image,"Captures an image from the user webcam",[])
-
-
-
-# Function to handle streaming callback
-def cb(chunk, type):
-    print(chunk, end="", flush=True)
-
-# Generate text with image
-response, function_calls = fcl.generate_with_functions_and_images(prompt="user: take a look at me then tell ma how i look.\nassistant: ", images=images, stream=False, temperature=0.5, streaming_callback=cb)
-print(f"response: {response}")
-if len(function_calls)>0:
-    results = fcl.execute_function_calls(function_calls)
-    result = "\n".join(results)
-    prompt="user: take a look at me then tell ma how i look.\nassistant: "+response + f"\nfunction execution result: {result}\nassistant: "
-    response, function_calls = fcl.generate_with_functions_and_images(prompt, images=images, stream=False, temperature=0.5, streaming_callback=cb)
-print(f"response: {response}")
-tts.text2Audio(response, random_voice)

lollms_client/lollms_functions.py

@@ -1,72 +0,0 @@
-from functools import partial
-from lollms_client.lollms_tasks import TasksLibrary
-from typing import Dict, Any, List
-
-class FunctionCalling_Library:
-    def __init__(self, tasks_library:TasksLibrary):
-        self.tl = tasks_library
-        self.function_definitions = []
-
-    def register_function(self, function_name, function_callable, function_description, function_parameters):
-        self.function_definitions.append({
-            "function_name": function_name,
-            "function": function_callable,
-            "function_description": function_description,
-            "function_parameters": function_parameters
-        })
-
-    def unregister_function(self, function_name):
-        self.function_definitions = [func for func in self.function_definitions if func["function_name"] != function_name]
-
-
-
-    def execute_function_calls(self, function_calls: List[Dict[str, Any]]) -> List[Any]:
-        """
-        Executes the function calls with the parameters extracted from the generated text,
-        using the original functions list to find the right function to execute.
-
-        Args:
-            function_calls (List[Dict[str, Any]]): A list of dictionaries representing the function calls.
-            function_definitions (List[Dict[str, Any]]): The original list of functions with their descriptions and callable objects.
-
-        Returns:
-            List[Any]: A list of results from executing the function calls.
-        """
-        results = []
-        # Convert function_definitions to a dict for easier lookup
-        functions_dict = {func['function_name']: func['function'] for func in self.function_definitions}
-
-        for call in function_calls:
-            function_name = call.get("function_name")
-            parameters = call.get("function_parameters", [])
-            function = functions_dict.get(function_name)
-
-            if function:
-                try:
-                    # Assuming parameters is a dictionary that maps directly to the function's arguments.
-                    if type(parameters)==list:
-                        result = function(*parameters)
-                    elif type(parameters)==dict:
-                        result = function(**parameters)
-                    results.append(result)
-                except TypeError as e:
-                    # Handle cases where the function call fails due to incorrect parameters, etc.
-                    results.append(f"Error calling {function_name}: {e}")
-            else:
-                results.append(f"Function {function_name} not found.")
-
-        return results
-    
-    def generate_with_functions(self, prompt, stream=False, temperature=0.5, streaming_callback=None):
-        # Assuming generate_with_function_calls is a method from TasksLibrary
-        ai_response, function_calls = self.tl.generate_with_function_calls(prompt, self.function_definitions, callback=streaming_callback)
-        return ai_response, function_calls
-
-    def generate_with_functions_and_images(self, prompt, images=[], stream=False, temperature=0.5, streaming_callback=None):
-        # Assuming generate_with_function_calls_and_images is a method from TasksLibrary
-        if len(images) > 0:
-            ai_response, function_calls = self.tl.generate_with_function_calls_and_images(prompt, images, self.function_definitions, callback=streaming_callback)
-        else:
-            ai_response, function_calls = self.tl.generate_with_function_calls(prompt, self.function_definitions)
-
-        return ai_response, function_calls