lollms-client 0.27.2__tar.gz → 0.28.0__tar.gz

{lollms_client-0.27.2 → lollms_client-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.27.2
+Version: 0.28.0
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License

lollms_client-0.28.0/examples/lollms_chat/calculator.py

@@ -0,0 +1,59 @@
+# This is a simple example of a calculator using lollms_chat. don't expect this to be perfect as LLMs are very bad in computing 
+# this can be used for very simple calculations. don't expect it to be accurate to compute sqrt(35) or something
+# it is just for the purpose of experimentation as even the best models in the world are not capable of doing accurate calculations yet without a calculator
+
+from lollms_client import LollmsClient
+import json
+import math  # Import the math module for calculations
+
+# Make sure you use your key
+lc = LollmsClient(
+    "openai",
+    "http://localhost:9642/v1/",
+    service_key="lollms_y-uyV-p2_AQGo5Ut6uHDmfIoRk6rKfmf0Rz6xQx-Zkl8cNyVUSFM"# make sure you generate your own key
+)
+
+# if you want to see what binding/model does the server support, use this:
+models = lc.listModels()
+print(f"Found models:\n{models}")
+
+lc.set_model_name("ollama/gemma3:27b")  # Or your preferred binding/model
+
+expression = input("Give an expression to evaluate: ")
+
+# Construct a detailed prompt
+system_prompt = (
+    "You are a highly accurate calculator.  You receive a mathematical expression "
+    "as input and return the result as a JSON object.  "
+    "The expression can include numbers, basic arithmetic operators (+, -, *, /), "
+    "parentheses, and common mathematical functions like sin, cos, tan, pi, sqrt, and log.  "
+    "Always evaluate the expression and return the final numeric result.  If the expression is invalid, return 'Error'."
+)
+
+template = '{"result": the numeric result of the evaluated expression}'
+
+# Include the expression in the user prompt.  This is important!
+user_prompt = f"Evaluate the following expression: {expression}"
+
+# Generate the code
+generation_output = lc.generate_code(
+    user_prompt,
+    system_prompt=system_prompt,
+    template=template
+)
+
+try:
+    # Attempt to parse the JSON response
+    generation_output = json.loads(generation_output)
+    result = generation_output["result"]
+
+    # Attempt to convert the result to a float
+    try:
+        result = float(result)
+        print(f"Result: {result}")
+    except ValueError:
+        print(f"Result: {result} (Could not convert to a number)") #Handles cases where the LLM returns non-numeric output
+except json.JSONDecodeError:
+    print(f"Error: Could not decode JSON response: {generation_output}")
+except KeyError:
+    print(f"Error: 'result' key not found in JSON response: {generation_output}")

lollms_client-0.28.0/examples/lollms_chat/derivative.py

@@ -0,0 +1,48 @@
+from lollms_client import LollmsClient
+import json
+
+# Make sure you use your key
+lc = LollmsClient(
+    "openai",
+    "http://localhost:9642/v1/",
+    service_key="lollms_y-uyV-p2_AQGo5Ut6uHDmfIoRk6rKfmf0Rz6xQx-Zkl8cNyVUSFM"  # make sure you generate your own key
+)
+
+# if you want to see what binding/model does the server support, use this:
+models = lc.listModels()
+print(f"Found models:\n{models}")
+
+lc.set_model_name("ollama/gemma3:27b")  # Or your preferred binding/model
+
+function = input("Enter the function (e.g., x^2 + 2*x): ")
+parameter = input("Enter the parameter to differentiate with respect to (e.g., x): ")
+
+# Construct a detailed prompt
+system_prompt = (
+    "You are a symbolic differentiation engine. You receive a mathematical function "
+    "and a parameter as input, and you return the derivative of the function with respect to that parameter. "
+    "The function can include variables, numbers, and common mathematical operations. "
+    "Return the derivative as a string. If the function or parameter is invalid, return 'Error'."
+)
+
+template = '"{derivative}": the derivative of the function with respect to the parameter'
+
+# Include the function and parameter in the user prompt. This is important!
+user_prompt = f"Find the derivative of the function '{function}' with respect to '{parameter}'."
+
+# Generate the code
+generation_output = lc.generate_code(
+    user_prompt,
+    system_prompt=system_prompt,
+    template=template
+)
+
+try:
+    # Attempt to parse the JSON response
+    generation_output = json.loads(generation_output)
+    derivative = generation_output["derivative"]
+    print(f"Derivative: {derivative}")
+except json.JSONDecodeError:
+    print(f"Error: Could not decode JSON response: {generation_output}")
+except KeyError:
+    print(f"Error: 'derivative' key not found in JSON response: {generation_output}")

lollms_client-0.28.0/examples/lollms_chat/test_openai_compatible_with_lollms_chat.py

@@ -0,0 +1,12 @@
+from lollms_client import LollmsClient
+#make sure you use your key
+lc = LollmsClient("openai","http://localhost:9642/v1/", service_key="lollms_zXQdyvrP_ecMXm3UZ0D004x979aHpyF8iq4ki_b52q0WdFuiEfMo")
+models = lc.listModels()
+print(f"Found models:\n{models}")
+
+lc.set_model_name("ollama/gemma3:27b")
+
+res = lc.generate_text("Describe this image",images=[
+    r"C:\Users\parisneo\Pictures\me.jpg"
+])
+print(res)

{lollms_client-0.27.2 → lollms_client-0.28.0}/lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "0.27.2" # Updated version
+__version__ = "0.28.0" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

{lollms_client-0.27.2 → lollms_client-0.28.0}/lollms_client/llm_bindings/litellm/__init__.py

@@ -110,6 +110,25 @@ class LiteLLMBinding(LollmsLLMBinding):
 
         return self._perform_generation(messages, n_predict, is_streaming, temperature, top_p, repeat_penalty, seed, streaming_callback)
 
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        is_streaming = stream if stream is not None else (streaming_callback is not None)
+        return self._perform_generation(messages, n_predict, is_streaming, temperature, top_p, repeat_penalty, seed, streaming_callback)
+        
+
     def chat(self, discussion: LollmsDiscussion, branch_tip_id: Optional[str] = None, n_predict: Optional[int] = None, stream: Optional[bool] = None, temperature: float = 0.7, top_p: float = 0.9, repeat_penalty: float = 1.1, seed: Optional[int] = None, streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None, **kwargs) -> Union[str, dict]:
         is_streaming = stream if stream is not None else (streaming_callback is not None)
         messages = discussion.export("openai_chat", branch_tip_id)
@@ -178,9 +197,9 @@ class LiteLLMBinding(LollmsLLMBinding):
                 entries.append({
                     "category": "api", "datasets": "unknown", "icon": get_icon_path(model_name),
                     "license": "unknown", "model_creator": model_info.get('owned_by', 'unknown'),
-                    "name": model_name, "provider": "litellm", "rank": "1.0", "type": "api",
+                    "model_name": model_name, "provider": "litellm", "rank": "1.0", "type": "api",
                     "variants": [{
-                        "name": model_name, "size": context_size,
+                        "model_name": model_name, "size": context_size,
                         "input_cost_per_token": model_info.get('input_cost_per_token', 0),
                         "output_cost_per_token": model_info.get('output_cost_per_token', 0),
                         "max_output_tokens": model_info.get('max_output_tokens', 0),

{lollms_client-0.27.2/lollms_client/llm_bindings/openai → lollms_client-0.28.0/lollms_client/llm_bindings/lollms_chat}/__init__.py

@@ -1,4 +1,4 @@
-# bindings/OpenAI/binding.py
+# bindings/Lollms_chat/binding.py
 import requests
 import json
 from lollms_client.lollms_llm_binding import LollmsLLMBinding
@@ -18,11 +18,11 @@ import openai
 import tiktoken
 import os
 
-BindingName = "OpenAIBinding"
+BindingName = "LollmsChatBinding"
 
 
-class OpenAIBinding(LollmsLLMBinding):
-    """OpenAI-specific binding implementation"""
+class LollmsChatBinding(LollmsLLMBinding):
+    """LollmsChat-specific binding implementation (open ai compatible with some extra parameters)"""
     
     
     def __init__(self,
@@ -229,6 +229,66 @@ class OpenAIBinding(LollmsLLMBinding):
 
         return output
     
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        # Build the request parameters
+        params = {
+            "model": self.model_name,
+            "messages": messages,
+            "max_tokens": n_predict,
+            "n": 1,
+            "temperature": temperature,
+            "top_p": top_p,
+            "frequency_penalty": repeat_penalty,
+            "stream": stream
+        }
+        # Add seed if available, as it's supported by newer OpenAI models
+        if seed is not None:
+            params["seed"] = seed
+
+        # Remove None values, as the API expects them to be absent
+        params = {k: v for k, v in params.items() if v is not None}
+        
+        output = ""
+        # 2. Call the API
+        try:
+            completion = self.client.chat.completions.create(**params)
+
+            if stream:
+                for chunk in completion:
+                    # The streaming response for chat has a different structure
+                    delta = chunk.choices[0].delta
+                    if delta.content:
+                        word = delta.content
+                        if streaming_callback is not None:
+                            if not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                        output += word
+            else:
+                output = completion.choices[0].message.content
+        
+        except Exception as e:
+            # Handle API errors gracefully
+            error_message = f"An error occurred with the OpenAI API: {e}"
+            if streaming_callback:
+                streaming_callback(error_message, MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {"status": "error", "message": error_message}
+            
+        return output
+    
     def chat(self,
              discussion: LollmsDiscussion,
              branch_tip_id: Optional[str] = None,
@@ -382,16 +442,40 @@ class OpenAIBinding(LollmsLLMBinding):
         
     def embed(self, text: str, **kwargs) -> list:
         """
-        Get embeddings for the input text using OpenAI API
-        
+        Get embeddings for the input text using OpenAI API.
+
         Args:
-            text (str or List[str]): Input text to embed
-            **kwargs: Additional arguments like model, truncate, options, keep_alive
-        
+            text (str): Input text to embed.
+            **kwargs: Additional arguments. The 'model' argument can be used 
+                      to specify the embedding model (e.g., "text-embedding-3-small").
+                      Defaults to "text-embedding-ada-002".
+
         Returns:
-            dict: Response containing embeddings
+            list: The embedding vector as a list of floats, or an empty list on failure.
         """
-        pass    
+        # Determine the embedding model, prioritizing kwargs, with a default
+        embedding_model = kwargs.get("model", self.model_name)
+        
+        try:
+            # The OpenAI API expects the input to be a list of strings
+            response = self.client.embeddings.create(
+                model=embedding_model,
+                input=[text]  # Wrap the single text string in a list
+            )
+            
+            # Extract the embedding from the response
+            if response.data and len(response.data) > 0:
+                return response.data[0].embedding
+            else:
+                ASCIIColors.warning("OpenAI API returned no data for the embedding request.")
+                return []
+                
+        except Exception as e:
+            ASCIIColors.error(f"Failed to generate embeddings using OpenAI API: {e}")
+            trace_exception(e)
+            return []
+        
+
     def get_model_info(self) -> dict:
         """
         Return information about the current OpenAI model.
@@ -457,6 +541,15 @@ class OpenAIBinding(LollmsLLMBinding):
                         "context_length": context_length,
                         "max_generation": max_generation,
                     })
+                else:
+                    models_info.append({
+                        "model_name": model_id,
+                        "owned_by": getattr(model, "owned_by", "N/A"),
+                        "created": getattr(model, "created", "N/A"),
+                        "context_length": None,
+                        "max_generation": None,
+                    })
+                    
         except Exception as e:
             print(f"Failed to list models: {e}")
 

{lollms_client-0.27.2 → lollms_client-0.28.0}/lollms_client/llm_bindings/ollama/__init__.py

@@ -258,7 +258,77 @@ class OllamaBinding(LollmsLLMBinding):
             error_message = f"An unexpected error occurred: {str(ex)}"
             trace_exception(ex)
             return {"status": False, "error": error_message}
+
+    def generate_from_messages(self,
+                     messages: List[Dict],
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        if not self.ollama_client:
+             return {"status": False, "error": "Ollama client not initialized."}
+
+        options = {}
+        if n_predict is not None: options['num_predict'] = n_predict
+        if temperature is not None: options['temperature'] = float(temperature)
+        if top_k is not None: options['top_k'] = top_k
+        if top_p is not None: options['top_p'] = top_p
+        if repeat_penalty is not None: options['repeat_penalty'] = repeat_penalty
+        if repeat_last_n is not None: options['repeat_last_n'] = repeat_last_n
+        if seed is not None: options['seed'] = seed
+        if n_threads is not None: options['num_thread'] = n_threads
+        if ctx_size is not None: options['num_ctx'] = ctx_size
+        
+        full_response_text = ""
+
+        try:
+            if stream:
+                response_stream = self.ollama_client.chat(
+                    model=self.model_name,
+                    messages=messages,
+                    stream=True,
+                    options=options if options else None
+                )
+                for chunk_dict in response_stream:
+                    chunk_content = chunk_dict.get('message', {}).get('content', '')
+                    if chunk_content: # Ensure there is content to process
+                        full_response_text += chunk_content
+                        if streaming_callback:
+                            if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break # Callback requested stop
+                return full_response_text
+            else: # Not streaming
+                response_dict = self.ollama_client.chat(
+                    model=self.model_name,
+                    messages=messages,
+                    stream=False,
+                    options=options if options else None
+                )
+                return response_dict.get('message', {}).get('content', '')
+
+        except ollama.ResponseError as e:
+            error_message = f"Ollama API ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message, "status_code": e.status_code}
+        except ollama.RequestError as e: # Covers connection errors, timeouts during request
+            error_message = f"Ollama API RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
     
+
     def chat(self,
              discussion: LollmsDiscussion,
              branch_tip_id: Optional[str] = None,

{lollms_client-0.27.2 → lollms_client-0.28.0}/lollms_client/llm_bindings/open_router/__init__.py

@@ -276,7 +276,6 @@ if __name__ == '__main__':
         binding.load_model("meta-llama/llama-3-8b-instruct:free") # Use the free tier on OpenRouter
         full_streamed_text = ""
         def stream_callback(chunk: str, msg_type: int):
-            nonlocal full_streamed_text
             ASCIIColors.green(chunk, end="", flush=True)
             full_streamed_text += chunk
             return True
@@ -301,4 +300,4 @@ if __name__ == '__main__':
         ASCIIColors.error(f"An error occurred during testing: {e}")
         trace_exception(e)
 
-    ASCIIColors.yellow("\nOpenRouterBinding test finished.")
+    ASCIIColors.yellow("\nOpenRouterBinding test finished.")