Upload Local_Summarization_Lib.py

App_Function_Libraries/Local_Summarization_Lib.py

@@ -21,6 +21,8 @@
 import json
 import logging
 import os
+from typing import Union
+
 import requests
 # Import 3rd-party Libraries
 from openai import OpenAI
@@ -38,7 +40,7 @@ logger = logging.getLogger()
 openai_api_key = "Fake_key"
 client = OpenAI(api_key=openai_api_key)
 
-def summarize_with_local_llm(input_data, custom_prompt_arg):
+def summarize_with_local_llm(input_data, custom_prompt_arg, temp, system_message=None):
     try:
         if isinstance(input_data, str) and os.path.isfile(input_data):
             logging.debug("Local LLM: Loading json data for summarization")
@@ -65,6 +67,9 @@ def summarize_with_local_llm(input_data, custom_prompt_arg):
         else:
             raise ValueError("Invalid input data format")
 
+        if system_message is None:
+            system_message = "You are a helpful AI assistant."
+
         headers = {
             'Content-Type': 'application/json'
         }
@@ -75,7 +80,7 @@ def summarize_with_local_llm(input_data, custom_prompt_arg):
             "messages": [
                 {
                     "role": "system",
-                    "content": "You are a professional summarizer."
+                    "content": system_message
                 },
                 {
                     "role": "user",
@@ -106,19 +111,25 @@ def summarize_with_local_llm(input_data, custom_prompt_arg):
         print("Error occurred while processing summary with Local LLM:", str(e))
         return "Local LLM: Error occurred while processing summary"
 
-def summarize_with_llama(input_data, custom_prompt, api_url="http://127.0.0.1:8080/completion", api_key=None):
-    loaded_config_data = load_and_log_configs()
+def summarize_with_llama(input_data, custom_prompt, api_url="http://127.0.0.1:8080/completion", api_key=None, temp=None, system_message=None):
     try:
-        # API key validation
-        if api_key is None:
-            logging.info("llama.cpp: API key not provided as parameter")
-            logging.info("llama.cpp: Attempting to use API key from config file")
-            api_key = loaded_config_data['api_keys']['llama']
-
-        if api_key is None or api_key.strip() == "":
-            logging.info("llama.cpp: API key not found or is empty")
-
-        logging.debug(f"llama.cpp: Using API Key: {api_key[:5]}...{api_key[-5:]}")
+        logging.debug("Llama.cpp: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            llama_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                llama_api_key = api_key
+                logging.info("Llama.cpp: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                llama_api_key = loaded_config_data['api_keys'].get('llama')
+                if llama_api_key:
+                    logging.info("Llama.cpp: Using API key from config file")
+                else:
+                    logging.warning("Llama.cpp: No API key found in config file")
 
         # Load transcript
         logging.debug("llama.cpp: Loading JSON data")
@@ -154,11 +165,20 @@ def summarize_with_llama(input_data, custom_prompt, api_url="http://127.0.0.1:80
         if len(api_key) > 5:
             headers['Authorization'] = f'Bearer {api_key}'
 
-        llama_prompt = f"{text} \n\n\n\n{custom_prompt}"
+        llama_prompt = f"{custom_prompt} \n\n\n\n{text}"
+        if system_message == None:
+            system_message = "You are a helpful AI assistant."
         logging.debug("llama: Prompt being sent is {llama_prompt}")
+        if system_message is None:
+            system_message = "You are a helpful AI assistant."
 
         data = {
-            "prompt": llama_prompt
+            "messages": [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": llama_prompt}
+            ],
+            "max_tokens": 4096,
+            "temperature": temp
         }
 
         logging.debug("llama: Submitting request to API endpoint")
@@ -184,17 +204,28 @@ def summarize_with_llama(input_data, custom_prompt, api_url="http://127.0.0.1:80
 
 
 # https://lite.koboldai.net/koboldcpp_api#/api%2Fv1/post_api_v1_generate
-def summarize_with_kobold(input_data, api_key, custom_prompt_input, kobold_api_IP="http://127.0.0.1:5001/api/v1/generate"):
-    loaded_config_data = load_and_log_configs()
+def summarize_with_kobold(input_data, api_key, custom_prompt_input, kobold_api_ip="http://127.0.0.1:5001/api/v1/generate", temp=None, system_message=None):
+    logging.debug("Kobold: Summarization process starting...")
     try:
-        # API key validation
-        if api_key is None:
-            logging.info("Kobold.cpp: API key not provided as parameter")
-            logging.info("Kobold.cpp: Attempting to use API key from config file")
-            api_key = loaded_config_data['api_keys']['kobold']
+        logging.debug("Kobold: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            kobold_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                kobold_api_key = api_key
+                logging.info("Kobold: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                kobold_api_key = loaded_config_data['api_keys'].get('kobold')
+                if kobold_api_key:
+                    logging.info("Kobold: Using API key from config file")
+                else:
+                    logging.warning("Kobold: No API key found in config file")
 
-        if api_key is None or api_key.strip() == "":
-            logging.info("Kobold.cpp: API key not found or is empty")
+        logging.debug(f"Kobold: Using API Key: {kobold_api_key[:5]}...{kobold_api_key[-5:]}")
 
         if isinstance(input_data, str) and os.path.isfile(input_data):
             logging.debug("Kobold.cpp: Loading json data for summarization")
@@ -226,7 +257,7 @@ def summarize_with_kobold(input_data, api_key, custom_prompt_input, kobold_api_I
             'content-type': 'application/json',
         }
 
-        kobold_prompt = f"{text} \n\n\n\n{custom_prompt_input}"
+        kobold_prompt = f"{custom_prompt_input}\n\n\n\n{text}"
         logging.debug("kobold: Prompt being sent is {kobold_prompt}")
 
         # FIXME
@@ -234,45 +265,69 @@ def summarize_with_kobold(input_data, api_key, custom_prompt_input, kobold_api_I
         data = {
             "max_context_length": 8096,
             "max_length": 4096,
-            "prompt": f"{text}\n\n\n\n{custom_prompt_input}"
+            "prompt": kobold_prompt,
+            "temperature": 0.7,
+            #"top_p": 0.9,
+            #"top_k": 100
+            #"rep_penalty": 1.0,
         }
 
         logging.debug("kobold: Submitting request to API endpoint")
         print("kobold: Submitting request to API endpoint")
-        response = requests.post(kobold_api_IP, headers=headers, json=data)
-        response_data = response.json()
-        logging.debug("kobold: API Response Data: %s", response_data)
-
-        if response.status_code == 200:
-            if 'results' in response_data and len(response_data['results']) > 0:
-                summary = response_data['results'][0]['text'].strip()
-                logging.debug("kobold: Summarization successful")
-                print("Summarization successful.")
-                return summary
+        kobold_api_ip = loaded_config_data['local_api_ip']['kobold']
+        try:
+            response = requests.post(kobold_api_ip, headers=headers, json=data)
+            logging.debug("kobold: API Response Status Code: %d", response.status_code)
+
+            if response.status_code == 200:
+                try:
+                    response_data = response.json()
+                    logging.debug("kobold: API Response Data: %s", response_data)
+
+                    if response_data and 'results' in response_data and len(response_data['results']) > 0:
+                        summary = response_data['results'][0]['text'].strip()
+                        logging.debug("kobold: Summarization successful")
+                        return summary
+                    else:
+                        logging.error("Expected data not found in API response.")
+                        return "Expected data not found in API response."
+                except ValueError as e:
+                    logging.error("kobold: Error parsing JSON response: %s", str(e))
+                    return f"Error parsing JSON response: {str(e)}"
             else:
-                logging.error("Expected data not found in API response.")
-                return "Expected data not found in API response."
-        else:
-            logging.error(f"kobold: API request failed with status code {response.status_code}: {response.text}")
-            return f"kobold: API request failed: {response.text}"
-
+                logging.error(f"kobold: API request failed with status code {response.status_code}: {response.text}")
+                return f"kobold: API request failed: {response.text}"
+        except Exception as e:
+            logging.error("kobold: Error in processing: %s", str(e))
+            return f"kobold: Error occurred while processing summary with kobold: {str(e)}"
     except Exception as e:
         logging.error("kobold: Error in processing: %s", str(e))
         return f"kobold: Error occurred while processing summary with kobold: {str(e)}"
 
 
 # https://github.com/oobabooga/text-generation-webui/wiki/12-%E2%80%90-OpenAI-API
-def summarize_with_oobabooga(input_data, api_key, custom_prompt, api_url="http://127.0.0.1:5000/v1/chat/completions"):
-    loaded_config_data = load_and_log_configs()
+def summarize_with_oobabooga(input_data, api_key, custom_prompt, api_url="http://127.0.0.1:5000/v1/chat/completions", temp=None, system_message=None):
+    logging.debug("Oobabooga: Summarization process starting...")
     try:
-        # API key validation
-        if api_key is None:
-            logging.info("ooba: API key not provided as parameter")
-            logging.info("ooba: Attempting to use API key from config file")
-            api_key = loaded_config_data['api_keys']['ooba']
+        logging.debug("Oobabooga: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            ooba_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                ooba_api_key = api_key
+                logging.info("Oobabooga: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                ooba_api_key = loaded_config_data['api_keys'].get('ooba')
+                if ooba_api_key:
+                    logging.info("Anthropic: Using API key from config file")
+                else:
+                    logging.warning("Anthropic: No API key found in config file")
 
-        if api_key is None or api_key.strip() == "":
-            logging.info("ooba: API key not found or is empty")
+        logging.debug(f"Oobabooga: Using API Key: {ooba_api_key[:5]}...{ooba_api_key[-5:]}")
 
         if isinstance(input_data, str) and os.path.isfile(input_data):
             logging.debug("Oobabooga: Loading json data for summarization")
@@ -310,10 +365,14 @@ def summarize_with_oobabooga(input_data, api_key, custom_prompt, api_url="http:/
         ooba_prompt = f"{text}" + f"\n\n\n\n{custom_prompt}"
         logging.debug("ooba: Prompt being sent is {ooba_prompt}")
 
+        if system_message is None:
+            system_message = "You are a helpful AI assistant."
+
         data = {
             "mode": "chat",
             "character": "Example",
-            "messages": [{"role": "user", "content": ooba_prompt}]
+            "messages": [{"role": "user", "content": ooba_prompt}],
+            "system_message": system_message,
         }
 
         logging.debug("ooba: Submitting request to API endpoint")
@@ -336,117 +395,310 @@ def summarize_with_oobabooga(input_data, api_key, custom_prompt, api_url="http:/
         return f"ooba: Error occurred while processing summary with oobabooga: {str(e)}"
 
 
-# FIXME - Install is more trouble than care to deal with right now.
-def summarize_with_tabbyapi(input_data, custom_prompt_input, api_key=None, api_IP="http://127.0.0.1:5000/v1/chat/completions"):
-    loaded_config_data = load_and_log_configs()
-    model = loaded_config_data['models']['tabby']
-    # API key validation
-    if api_key is None:
-        logging.info("tabby: API key not provided as parameter")
-        logging.info("tabby: Attempting to use API key from config file")
-        api_key = loaded_config_data['api_keys']['tabby']
-
-    if api_key is None or api_key.strip() == "":
-        logging.info("tabby: API key not found or is empty")
-
-    if isinstance(input_data, str) and os.path.isfile(input_data):
-        logging.debug("tabby: Loading json data for summarization")
-        with open(input_data, 'r') as file:
-            data = json.load(file)
-    else:
-        logging.debug("tabby: Using provided string data for summarization")
-        data = input_data
-
-    logging.debug(f"tabby: Loaded data: {data}")
-    logging.debug(f"tabby: Type of data: {type(data)}")
-
-    if isinstance(data, dict) and 'summary' in data:
-        # If the loaded data is a dictionary and already contains a summary, return it
-        logging.debug("tabby: Summary already exists in the loaded data")
-        return data['summary']
-
-    # If the loaded data is a list of segment dictionaries or a string, proceed with summarization
-    if isinstance(data, list):
-        segments = data
-        text = extract_text_from_segments(segments)
-    elif isinstance(data, str):
-        text = data
-    else:
-        raise ValueError("Invalid input data format")
-
-    headers = {
-        'Authorization': f'Bearer {api_key}',
-        'Content-Type': 'application/json'
-    }
-    data2 = {
-        'text': text,
-        'model': 'tabby'  # Specify the model if needed
-    }
-    tabby_api_ip = loaded_config_data['local_apis']['tabby']['ip']
+
+def summarize_with_tabbyapi(input_data, custom_prompt_input, api_key=None, api_IP="http://127.0.0.1:5000/v1/chat/completions", temp=None, system_message=None):
+    logging.debug("TabbyAPI: Summarization process starting...")
     try:
+        logging.debug("TabbyAPI: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            tabby_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                tabby_api_key = api_key
+                logging.info("TabbyAPI: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                tabby_api_key = loaded_config_data['api_keys'].get('tabby')
+                if tabby_api_key:
+                    logging.info("TabbyAPI: Using API key from config file")
+                else:
+                    logging.warning("TabbyAPI: No API key found in config file")
+
+        tabby_api_ip = loaded_config_data['local_api_ip']['tabby']
+        tabby_model = loaded_config_data['models']['tabby']
+        if temp is None:
+            temp = 0.7
+
+        logging.debug(f"TabbyAPI: Using API Key: {tabby_api_key[:5]}...{tabby_api_key[-5:]}")
+
+        if isinstance(input_data, str) and os.path.isfile(input_data):
+            logging.debug("tabby: Loading json data for summarization")
+            with open(input_data, 'r') as file:
+                data = json.load(file)
+        else:
+            logging.debug("tabby: Using provided string data for summarization")
+            data = input_data
+
+        logging.debug(f"tabby: Loaded data: {data}")
+        logging.debug(f"tabby: Type of data: {type(data)}")
+
+        if isinstance(data, dict) and 'summary' in data:
+            # If the loaded data is a dictionary and already contains a summary, return it
+            logging.debug("tabby: Summary already exists in the loaded data")
+            return data['summary']
+
+        # If the loaded data is a list of segment dictionaries or a string, proceed with summarization
+        if isinstance(data, list):
+            segments = data
+            text = extract_text_from_segments(segments)
+        elif isinstance(data, str):
+            text = data
+        else:
+            raise ValueError("Invalid input data format")
+        if system_message is None:
+            system_message = "You are a helpful AI assistant."
+
+        headers = {
+            'Authorization': f'Bearer {api_key}',
+            'Content-Type': 'application/json'
+        }
+        data2 = {
+            'max_tokens': 4096,
+            "min_tokens": 0,
+            'temperature': temp,
+            #'top_p': 1.0,
+            #'top_k': 0,
+            #'frequency_penalty': 0,
+            #'presence_penalty': 0.0,
+            #"repetition_penalty": 1.0,
+            'model': tabby_model,
+            'user': custom_prompt_input,
+            'messages': input_data
+        }
+
         response = requests.post(tabby_api_ip, headers=headers, json=data2)
-        response.raise_for_status()
-        summary = response.json().get('summary', '')
-        return summary
+
+        if response.status_code == 200:
+            response_json = response.json()
+
+            # Validate the response structure
+            if all(key in response_json for key in ['id', 'choices', 'created', 'model', 'object', 'usage']):
+                logging.info("TabbyAPI: Received a valid 200 response")
+                summary = response_json['choices'][0].get('message', {}).get('content', '')
+                return summary
+            else:
+                logging.error("TabbyAPI: Received a 200 response, but the structure is invalid")
+                return "Error: Received an invalid response structure from TabbyAPI."
+
+        elif response.status_code == 422:
+            logging.error(f"TabbyAPI: Received a 422 error. Details: {response.json()}")
+            return "Error: Invalid request sent to TabbyAPI."
+
+        else:
+            response.raise_for_status()  # This will raise an exception for other status codes
+
     except requests.exceptions.RequestException as e:
-        logger.error(f"Error summarizing with TabbyAPI: {e}")
-        return "Error summarizing with TabbyAPI."
-
-
-# FIXME - https://docs.vllm.ai/en/latest/getting_started/quickstart.html .... Great docs.
-def summarize_with_vllm(input_data, custom_prompt_input, api_key=None, vllm_api_url="http://127.0.0.1:8000/v1/chat/completions"):
-    loaded_config_data = load_and_log_configs()
-    llm_model = loaded_config_data['models']['vllm']
-    # API key validation
-    if api_key is None:
-        logging.info("vLLM: API key not provided as parameter")
-        logging.info("vLLM: Attempting to use API key from config file")
-        api_key = loaded_config_data['api_keys']['llama']
-
-    if api_key is None or api_key.strip() == "":
-        logging.info("vLLM: API key not found or is empty")
-    vllm_client = OpenAI(
-        base_url=vllm_api_url,
-        api_key=custom_prompt_input
-    )
-
-    if isinstance(input_data, str) and os.path.isfile(input_data):
-        logging.debug("vLLM: Loading json data for summarization")
-        with open(input_data, 'r') as file:
-            data = json.load(file)
-    else:
-        logging.debug("vLLM: Using provided string data for summarization")
-        data = input_data
-
-    logging.debug(f"vLLM: Loaded data: {data}")
-    logging.debug(f"vLLM: Type of data: {type(data)}")
-
-    if isinstance(data, dict) and 'summary' in data:
-        # If the loaded data is a dictionary and already contains a summary, return it
-        logging.debug("vLLM: Summary already exists in the loaded data")
-        return data['summary']
-
-    # If the loaded data is a list of segment dictionaries or a string, proceed with summarization
-    if isinstance(data, list):
-        segments = data
-        text = extract_text_from_segments(segments)
-    elif isinstance(data, str):
-        text = data
-    else:
-        raise ValueError("Invalid input data format")
-
-
-    custom_prompt = custom_prompt_input
-
-    completion = client.chat.completions.create(
-        model=llm_model,
-        messages=[
-            {"role": "system", "content": "You are a professional summarizer."},
-            {"role": "user", "content": f"{text} \n\n\n\n{custom_prompt}"}
-        ]
-    )
-    vllm_summary = completion.choices[0].message.content
-    return vllm_summary
+        logging.error(f"Error summarizing with TabbyAPI: {e}")
+        return f"Error summarizing with TabbyAPI: {str(e)}"
+    except json.JSONDecodeError:
+        logging.error("TabbyAPI: Received an invalid JSON response")
+        return "Error: Received an invalid JSON response from TabbyAPI."
+    except Exception as e:
+        logging.error(f"Unexpected error in summarize_with_tabbyapi: {e}")
+        return f"Unexpected error in summarization process: {str(e)}"
+
+def summarize_with_vllm(
+        input_data: Union[str, dict, list],
+        custom_prompt_input: str,
+        api_key: str = None,
+        vllm_api_url: str = "http://127.0.0.1:8000/v1/chat/completions",
+        model: str = None,
+        system_prompt: str = None,
+        temp: float = 0.7
+) -> str:
+    logging.debug("vLLM: Summarization process starting...")
+    try:
+        logging.debug("vLLM: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            vllm_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                vllm_api_key = api_key
+                logging.info("vLLM: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                vllm_api_key = loaded_config_data['api_keys'].get('vllm')
+                if vllm_api_key:
+                    logging.info("vLLM: Using API key from config file")
+                else:
+                    logging.warning("vLLM: No API key found in config file")
+
+        logging.debug(f"vLLM: Using API Key: {vllm_api_key[:5]}...{vllm_api_key[-5:]}")
+        # Process input data
+        if isinstance(input_data, str) and os.path.isfile(input_data):
+            logging.debug("vLLM: Loading json data for summarization")
+            with open(input_data, 'r') as file:
+                data = json.load(file)
+        else:
+            logging.debug("vLLM: Using provided data for summarization")
+            data = input_data
+
+        logging.debug(f"vLLM: Type of data: {type(data)}")
+
+        # Extract text for summarization
+        if isinstance(data, dict) and 'summary' in data:
+            logging.debug("vLLM: Summary already exists in the loaded data")
+            return data['summary']
+        elif isinstance(data, list):
+            text = extract_text_from_segments(data)
+        elif isinstance(data, str):
+            text = data
+        elif isinstance(data, dict):
+            text = json.dumps(data)
+        else:
+            raise ValueError("Invalid input data format")
+
+        logging.debug(f"vLLM: Extracted text (showing first 500 chars): {text[:500]}...")
+
+        if system_prompt is None:
+            system_prompt = "You are a helpful AI assistant."
+
+        model = model or loaded_config_data['models']['vllm']
+        if system_prompt is None:
+            system_prompt = "You are a helpful AI assistant."
+
+        # Prepare the API request
+        headers = {
+            "Content-Type": "application/json"
+        }
+
+        payload = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": f"{custom_prompt_input}\n\n{text}"}
+            ]
+        }
+
+        # Make the API call
+        logging.debug(f"vLLM: Sending request to {vllm_api_url}")
+        response = requests.post(vllm_api_url, headers=headers, json=payload)
+
+        # Check for successful response
+        response.raise_for_status()
+
+        # Extract and return the summary
+        response_data = response.json()
+        if 'choices' in response_data and len(response_data['choices']) > 0:
+            summary = response_data['choices'][0]['message']['content']
+            logging.debug("vLLM: Summarization successful")
+            logging.debug(f"vLLM: Summary (first 500 chars): {summary[:500]}...")
+            return summary
+        else:
+            raise ValueError("Unexpected response format from vLLM API")
+
+    except requests.RequestException as e:
+        logging.error(f"vLLM: API request failed: {str(e)}")
+        return f"Error: vLLM API request failed - {str(e)}"
+    except json.JSONDecodeError as e:
+        logging.error(f"vLLM: Failed to parse API response: {str(e)}")
+        return f"Error: Failed to parse vLLM API response - {str(e)}"
+    except Exception as e:
+        logging.error(f"vLLM: Unexpected error during summarization: {str(e)}")
+        return f"Error: Unexpected error during vLLM summarization - {str(e)}"
+
+
+def summarize_with_ollama(input_data, custom_prompt, api_url="http://127.0.0.1:11434/api/generate", api_key=None, temp=None, system_message=None, model=None):
+    try:
+        logging.debug("ollama: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            ollama_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                ollama_api_key = api_key
+                logging.info("Ollama: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                ollama_api_key = loaded_config_data['api_keys'].get('ollama')
+                if ollama_api_key:
+                    logging.info("Ollama: Using API key from config file")
+                else:
+                    logging.warning("Ollama: No API key found in config file")
+
+        model = loaded_config_data['models']['ollama']
+
+        # Load transcript
+        logging.debug("Ollama: Loading JSON data")
+        if isinstance(input_data, str) and os.path.isfile(input_data):
+            logging.debug("Ollama: Loading json data for summarization")
+            with open(input_data, 'r') as file:
+                data = json.load(file)
+        else:
+            logging.debug("Ollama: Using provided string data for summarization")
+            data = input_data
+
+        logging.debug(f"Ollama: Loaded data: {data}")
+        logging.debug(f"Ollama: Type of data: {type(data)}")
+
+        if isinstance(data, dict) and 'summary' in data:
+            # If the loaded data is a dictionary and already contains a summary, return it
+            logging.debug("Ollama: Summary already exists in the loaded data")
+            return data['summary']
+
+        # If the loaded data is a list of segment dictionaries or a string, proceed with summarization
+        if isinstance(data, list):
+            segments = data
+            text = extract_text_from_segments(segments)
+        elif isinstance(data, str):
+            text = data
+        else:
+            raise ValueError("Ollama: Invalid input data format")
+
+        headers = {
+            'accept': 'application/json',
+            'content-type': 'application/json',
+        }
+        if len(ollama_api_key) > 5:
+            headers['Authorization'] = f'Bearer {ollama_api_key}'
+
+        ollama_prompt = f"{custom_prompt} \n\n\n\n{text}"
+        if system_message == None:
+            system_message = "You are a helpful AI assistant."
+        logging.debug(f"llama: Prompt being sent is {ollama_prompt}")
+        if system_message is None:
+            system_message = "You are a helpful AI assistant."
+
+        data = {
+            "model": model,
+            "messages": [
+                {"role": "system",
+                 "content": system_message
+                 },
+                {"role": "user",
+                 "content": ollama_prompt
+                 }
+            ],
+        }
+
+        logging.debug("Ollama: Submitting request to API endpoint")
+        print("Ollama: Submitting request to API endpoint")
+        response = requests.post(api_url, headers=headers, json=data)
+        response_data = response.json()
+        logging.debug("API Response Data: %s", response_data)
+
+        if response.status_code == 200:
+            # if 'X' in response_data:
+            logging.debug(response_data)
+            summary = response_data['content'].strip()
+            logging.debug("Ollama: Summarization successful")
+            print("Summarization successful.")
+            return summary
+        else:
+            logging.error(f"Ollama: API request failed with status code {response.status_code}: {response.text}")
+            return f"Ollama: API request failed: {response.text}"
+
+    except Exception as e:
+        logging.error("Ollama: Error in processing: %s", str(e))
+        return f"Ollama: Error occurred while processing summary with ollama: {str(e)}"
 
 
 def save_summary_to_file(summary, file_path):