Upload 2 files

App_Function_Libraries/LLM_API_Calls.py

@@ -25,15 +25,15 @@ import json
 import logging
 import os
 import time
+from typing import List
+
 import requests
 #
 # Import 3rd-Party Libraries
-from openai import OpenAI
 from requests import RequestException
 #
 # Import Local libraries
-from App_Function_Libraries.Local_Summarization_Lib import openai_api_key, client
-from App_Function_Libraries.Utils import load_and_log_configs
+from App_Function_Libraries.Utils.Utils import load_and_log_configs
 #
 #######################################################################################################################
 # Function Definitions
@@ -62,21 +62,78 @@ def extract_text_from_segments(segments):
 
 
 
-def chat_with_openai(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
+def get_openai_embeddings(input_data: str, model: str) -> List[float]:
+    """
+    Get embeddings for the input text from OpenAI API.
+
+    Args:
+        input_data (str): The input text to get embeddings for.
+        model (str): The model to use for generating embeddings.
+
+    Returns:
+        List[float]: The embeddings generated by the API.
+    """
     loaded_config_data = load_and_log_configs()
+    api_key = loaded_config_data['api_keys']['openai']
+
+    if not api_key:
+        logging.error("OpenAI: API key not found or is empty")
+        raise ValueError("OpenAI: API Key Not Provided/Found in Config file or is empty")
+
+    logging.debug(f"OpenAI: Using API Key: {api_key[:5]}...{api_key[-5:]}")
+    logging.debug(f"OpenAI: Raw input data (first 500 chars): {str(input_data)[:500]}...")
+    logging.debug(f"OpenAI: Using model: {model}")
+
+    headers = {
+        'Authorization': f'Bearer {api_key}',
+        'Content-Type': 'application/json'
+    }
+
+    request_data = {
+        "input": input_data,
+        "model": model,
+    }
+
+    try:
+        logging.debug("OpenAI: Posting request to embeddings API")
+        response = requests.post('https://api.openai.com/v1/embeddings', headers=headers, json=request_data)
+        logging.debug(f"Full API response data: {response}")
+        if response.status_code == 200:
+            response_data = response.json()
+            if 'data' in response_data and len(response_data['data']) > 0:
+                embedding = response_data['data'][0]['embedding']
+                logging.debug("OpenAI: Embeddings retrieved successfully")
+                return embedding
+            else:
+                logging.warning("OpenAI: Embedding data not found in the response")
+                raise ValueError("OpenAI: Embedding data not available in the response")
+        else:
+            logging.error(f"OpenAI: Embeddings request failed with status code {response.status_code}")
+            logging.error(f"OpenAI: Error response: {response.text}")
+            raise ValueError(f"OpenAI: Failed to retrieve embeddings. Status code: {response.status_code}")
+    except requests.RequestException as e:
+        logging.error(f"OpenAI: Error making API request: {str(e)}", exc_info=True)
+        raise ValueError(f"OpenAI: Error making API request: {str(e)}")
+    except Exception as e:
+        logging.error(f"OpenAI: Unexpected error: {str(e)}", exc_info=True)
+        raise ValueError(f"OpenAI: Unexpected error occurred: {str(e)}")
 
+
+def chat_with_openai(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
+    loaded_config_data = load_and_log_configs()
+    openai_api_key = api_key
     try:
         # API key validation
-        if api_key is None or api_key.strip() == "":
-            logging.info("OpenAI: #1 API key not provided as parameter")
+        if not openai_api_key:
+            logging.info("OpenAI: API key not provided as parameter")
             logging.info("OpenAI: Attempting to use API key from config file")
-            api_key = loaded_config_data['api_keys']['openai']
+            openai_api_key = loaded_config_data['api_keys']['openai']
 
-        if api_key is None or api_key.strip() == "":
-            logging.error("OpenAI: #2 API key not found or is empty")
+        if not openai_api_key:
+            logging.error("OpenAI: API key not found or is empty")
             return "OpenAI: API Key Not Provided/Found in Config file or is empty"
 
-        logging.debug(f"OpenAI: Using API Key: {api_key[:5]}...{api_key[-5:]}")
+        logging.debug(f"OpenAI: Using API Key: {openai_api_key[:5]}...{openai_api_key[-5:]}")
 
         # Input data handling
         logging.debug(f"OpenAI: Raw input data type: {type(input_data)}")
@@ -120,7 +177,6 @@ def chat_with_openai(api_key, input_data, custom_prompt_arg, temp=None, system_m
         else:
             raise ValueError(f"OpenAI: Invalid input data format: {type(data)}")
 
-        openai_model = loaded_config_data['models']['openai'] or "gpt-4o"
         logging.debug(f"OpenAI: Extracted text (first 500 chars): {text[:500]}...")
         logging.debug(f"OpenAI: Custom prompt: {custom_prompt_arg}")
 
@@ -153,12 +209,14 @@ def chat_with_openai(api_key, input_data, custom_prompt_arg, temp=None, system_m
 
         logging.debug("OpenAI: Posting request")
         response = requests.post('https://api.openai.com/v1/chat/completions', headers=headers, json=data)
-
+        logging.debug(f"Full API response data: {response}")
         if response.status_code == 200:
             response_data = response.json()
+            logging.debug(response_data)
             if 'choices' in response_data and len(response_data['choices']) > 0:
                 chat_response = response_data['choices'][0]['message']['content'].strip()
                 logging.debug("openai: Chat Sent successfully")
+                logging.debug(f"openai: Chat response: {chat_response}")
                 return chat_response
             else:
                 logging.warning("openai: Chat response not found in the response data")
@@ -182,13 +240,14 @@ def chat_with_anthropic(api_key, input_data, model, custom_prompt_arg, max_retri
     try:
         loaded_config_data = load_and_log_configs()
         global anthropic_api_key
+        anthropic_api_key = api_key
         # API key validation
-        if api_key is None:
+        if not api_key:
             logging.info("Anthropic: API key not provided as parameter")
             logging.info("Anthropic: Attempting to use API key from config file")
             anthropic_api_key = loaded_config_data['api_keys']['anthropic']
 
-        if api_key is None or api_key.strip() == "":
+        if not api_key or api_key.strip() == "":
             logging.error("Anthropic: API key not found or is empty")
             return "Anthropic: API Key Not Provided/Found in Config file or is empty"
 
@@ -237,7 +296,7 @@ def chat_with_anthropic(api_key, input_data, model, custom_prompt_arg, max_retri
             try:
                 logging.debug("anthropic: Posting request to API")
                 response = requests.post('https://api.anthropic.com/v1/messages', headers=headers, json=data)
-
+                logging.debug(f"Full API response data: {response}")
                 # Check if the status code indicates success
                 if response.status_code == 200:
                     logging.debug("anthropic: Post submittal successful")
@@ -275,15 +334,16 @@ def chat_with_anthropic(api_key, input_data, model, custom_prompt_arg, max_retri
 # Summarize with Cohere
 def chat_with_cohere(api_key, input_data, model, custom_prompt_arg, system_prompt=None):
     global cohere_api_key
+    cohere_api_key = api_key
     loaded_config_data = load_and_log_configs()
     try:
         # API key validation
-        if api_key is None:
+        if not api_key:
             logging.info("cohere: API key not provided as parameter")
             logging.info("cohere: Attempting to use API key from config file")
             cohere_api_key = loaded_config_data['api_keys']['cohere']
 
-        if api_key is None or api_key.strip() == "":
+        if not api_key or api_key.strip() == "":
             logging.error("cohere: API key not found or is empty")
             return "cohere: API Key Not Provided/Found in Config file or is empty"
 
@@ -324,7 +384,7 @@ def chat_with_cohere(api_key, input_data, model, custom_prompt_arg, system_promp
         print("cohere: Submitting request to API endpoint")
         response = requests.post('https://api.cohere.ai/v1/chat', headers=headers, json=data)
         response_data = response.json()
-        logging.debug("API Response Data: %s", response_data)
+        logging.debug(f"Full API response data: {response_data}")
 
         if response.status_code == 200:
             if 'text' in response_data:
@@ -439,9 +499,10 @@ def chat_with_groq(api_key, input_data, custom_prompt_arg, temp=None, system_mes
         response = requests.post('https://api.groq.com/openai/v1/chat/completions', headers=headers, json=data)
 
         response_data = response.json()
-        logging.debug("API Response Data: %s", response_data)
+        logging.debug(f"Full API response data: {response_data}")
 
         if response.status_code == 200:
+            logging.debug(response_data)
             if 'choices' in response_data and len(response_data['choices']) > 0:
                 summary = response_data['choices'][0]['message']['content'].strip()
                 logging.debug("groq: Chat request successful")
@@ -554,7 +615,7 @@ def chat_with_openrouter(api_key, input_data, custom_prompt_arg, temp=None, syst
         )
 
         response_data = response.json()
-        logging.debug("API Response Data: %s", response_data)
+        logging.debug("Full API Response Data: %s", response_data)
 
         if response.status_code == 200:
             if 'choices' in response_data and len(response_data['choices']) > 0:
@@ -580,11 +641,11 @@ def chat_with_huggingface(api_key, input_data, custom_prompt_arg, system_prompt=
     logging.debug(f"huggingface: Summarization process starting...")
     try:
         # API key validation
-        if api_key is None:
+        if not api_key:
             logging.info("HuggingFace: API key not provided as parameter")
             logging.info("HuggingFace: Attempting to use API key from config file")
             huggingface_api_key = loaded_config_data['api_keys']['openai']
-        if api_key is None or api_key.strip() == "":
+        if not api_key or api_key.strip() == "":
             logging.error("HuggingFace: API key not found or is empty")
             return "HuggingFace: API Key Not Provided/Found in Config file or is empty"
         logging.debug(f"HuggingFace: Using API Key: {api_key[:5]}...{api_key[-5:]}")
@@ -611,9 +672,9 @@ def chat_with_huggingface(api_key, input_data, custom_prompt_arg, system_prompt=
         logging.debug("huggingface: Submitting request...")
 
         response = requests.post(API_URL, headers=headers, json=data)
-
+        logging.debug(f"Full API response data: {response}")
         if response.status_code == 200:
-            summary = response.json()[0]['summary_text']
+            summary = response.json()[0]['generated_text'].strip()
             logging.debug("huggingface: Chat request successful")
             print("Chat request successful.")
             return summary
@@ -712,9 +773,10 @@ def chat_with_deepseek(api_key, input_data, custom_prompt_arg, temp=None, system
 
         logging.debug("DeepSeek: Posting request")
         response = requests.post('https://api.deepseek.com/chat/completions', headers=headers, json=data)
-
+        logging.debug(f"Full API response data: {response}")
         if response.status_code == 200:
             response_data = response.json()
+            logging.debug(response_data)
             if 'choices' in response_data and len(response_data['choices']) > 0:
                 summary = response_data['choices'][0]['message']['content'].strip()
                 logging.debug("DeepSeek: Chat request successful")
@@ -802,9 +864,10 @@ def chat_with_mistral(api_key, input_data, custom_prompt_arg, temp=None, system_
 
         logging.debug("Mistral: Posting request")
         response = requests.post('https://api.mistral.ai/v1/chat/completions', headers=headers, json=data)
-
+        logging.debug(f"Full API response data: {response}")
         if response.status_code == 200:
             response_data = response.json()
+            logging.debug(response_data)
             if 'choices' in response_data and len(response_data['choices']) > 0:
                 summary = response_data['choices'][0]['message']['content'].strip()
                 logging.debug("Mistral: request successful")
@@ -824,59 +887,59 @@ def chat_with_mistral(api_key, input_data, custom_prompt_arg, temp=None, system_
 
 # Stashed in here since OpenAI usage.... #FIXME
 # FIXME - https://docs.vllm.ai/en/latest/getting_started/quickstart.html .... Great docs.
-def chat_with_vllm(input_data, custom_prompt_input, api_key=None, vllm_api_url="http://127.0.0.1:8000/v1/chat/completions", system_prompt=None):
-    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": f"{system_prompt}"},
-            {"role": "user", "content": f"{text} \n\n\n\n{custom_prompt}"}
-        ]
-    )
-    vllm_summary = completion.choices[0].message.content
-    return vllm_summary
+# def chat_with_vllm(input_data, custom_prompt_input, api_key=None, vllm_api_url="http://127.0.0.1:8000/v1/chat/completions", system_prompt=None):
+#     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": f"{system_prompt}"},
+#             {"role": "user", "content": f"{text} \n\n\n\n{custom_prompt}"}
+#         ]
+#     )
+#     vllm_summary = completion.choices[0].message.content
+#     return vllm_summary
 
 
 

App_Function_Libraries/LLM_API_Calls_Local.py

@@ -4,10 +4,11 @@
 # This library is used to perform summarization with a 'local' inference engine.
 #
 ####
+from typing import Union
 
 ####################
 # Function List
-# FIXME - UPDATE Function Arguments
+# FIXME - UPDATE
 # 1. chat_with_local_llm(text, custom_prompt_arg)
 # 2. chat_with_llama(api_url, text, token, custom_prompt)
 # 3. chat_with_kobold(api_url, text, kobold_api_token, custom_prompt)
@@ -20,7 +21,7 @@
 ####################
 # Import necessary libraries
 # Import Local
-from Utils import *
+from App_Function_Libraries.Utils.Utils import *
 #
 #######################################################################################################################
 # Function Definitions
@@ -399,8 +400,324 @@ def chat_with_aphrodite(input_data, custom_prompt_input, api_key=None, api_IP="h
         return "Error summarizing with Aphrodite."
 
 
-def chat_with_ollama(input_data, prompt, temp, system_message):
-    pass
+# FIXME
+def chat_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 is 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: Chat request successful")
+            print("\n\nChat request successful.")
+            return summary
+        else:
+            logging.error(f"\n\nOllama: 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("\n\nOllama: Error in processing: %s", str(e))
+        return f"Ollama: Error occurred while processing summary with ollama: {str(e)}"
+
+def chat_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 chat_with_custom_openai(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
+    loaded_config_data = load_and_log_configs()
+    custom_openai_api_key = api_key
+    try:
+        # API key validation
+        if not custom_openai_api_key:
+            logging.info("Custom OpenAI API: API key not provided as parameter")
+            logging.info("Custom OpenAI API: Attempting to use API key from config file")
+            custom_openai_api_key = loaded_config_data['api_keys']['custom_openai_api_key']
+
+        if not custom_openai_api_key:
+            logging.error("Custom OpenAI API: API key not found or is empty")
+            return "Custom OpenAI API: API Key Not Provided/Found in Config file or is empty"
+
+        logging.debug(f"Custom OpenAI API: Using API Key: {custom_openai_api_key[:5]}...{custom_openai_api_key[-5:]}")
+
+        # Input data handling
+        logging.debug(f"Custom OpenAI API: Raw input data type: {type(input_data)}")
+        logging.debug(f"Custom OpenAI API: Raw input data (first 500 chars): {str(input_data)[:500]}...")
+
+        if isinstance(input_data, str):
+            if input_data.strip().startswith('{'):
+                # It's likely a JSON string
+                logging.debug("Custom OpenAI API: Parsing provided JSON string data for summarization")
+                try:
+                    data = json.loads(input_data)
+                except json.JSONDecodeError as e:
+                    logging.error(f"Custom OpenAI API: Error parsing JSON string: {str(e)}")
+                    return f"Custom OpenAI API: Error parsing JSON input: {str(e)}"
+            elif os.path.isfile(input_data):
+                logging.debug("Custom OpenAI API: Loading JSON data from file for summarization")
+                with open(input_data, 'r') as file:
+                    data = json.load(file)
+            else:
+                logging.debug("Custom OpenAI API: Using provided string data for summarization")
+                data = input_data
+        else:
+            data = input_data
+
+        logging.debug(f"Custom OpenAI API: Processed data type: {type(data)}")
+        logging.debug(f"Custom OpenAI API: Processed data (first 500 chars): {str(data)[:500]}...")
+
+        # Text extraction
+        if isinstance(data, dict):
+            if 'summary' in data:
+                logging.debug("Custom OpenAI API: Summary already exists in the loaded data")
+                return data['summary']
+            elif 'segments' in data:
+                text = extract_text_from_segments(data['segments'])
+            else:
+                text = json.dumps(data)  # Convert dict to string if no specific format
+        elif isinstance(data, list):
+            text = extract_text_from_segments(data)
+        elif isinstance(data, str):
+            text = data
+        else:
+            raise ValueError(f"Custom OpenAI API: Invalid input data format: {type(data)}")
+
+        logging.debug(f"Custom OpenAI API: Extracted text (first 500 chars): {text[:500]}...")
+        logging.debug(f"v: Custom prompt: {custom_prompt_arg}")
+
+        openai_model = loaded_config_data['models']['openai'] or "gpt-4o"
+        logging.debug(f"Custom OpenAI API: Using model: {openai_model}")
+
+        headers = {
+            'Authorization': f'Bearer {custom_openai_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        logging.debug(
+            f"OpenAI API Key: {custom_openai_api_key[:5]}...{custom_openai_api_key[-5:] if custom_openai_api_key else None}")
+        logging.debug("Custom OpenAI API: Preparing data + prompt for submittal")
+        openai_prompt = f"{text} \n\n\n\n{custom_prompt_arg}"
+        if temp is None:
+            temp = 0.7
+        if system_message is None:
+            system_message = "You are a helpful AI assistant who does whatever the user requests."
+        temp = float(temp)
+        data = {
+            "model": openai_model,
+            "messages": [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": openai_prompt}
+            ],
+            "max_tokens": 4096,
+            "temperature": temp
+        }
+
+        custom_openai_url = loaded_config_data['Local_api_ip']['custom_openai_api_ip']
+
+        logging.debug("Custom OpenAI API: Posting request")
+        response = requests.post(custom_openai_url, headers=headers, json=data)
+        logging.debug(f"Custom OpenAI API full API response data: {response}")
+        if response.status_code == 200:
+            response_data = response.json()
+            logging.debug(response_data)
+            if 'choices' in response_data and len(response_data['choices']) > 0:
+                chat_response = response_data['choices'][0]['message']['content'].strip()
+                logging.debug("Custom OpenAI API: Chat Sent successfully")
+                logging.debug(f"Custom OpenAI API: Chat response: {chat_response}")
+                return chat_response
+            else:
+                logging.warning("Custom OpenAI API: Chat response not found in the response data")
+                return "Custom OpenAI API: Chat not available"
+        else:
+            logging.error(f"Custom OpenAI API: Chat request failed with status code {response.status_code}")
+            logging.error(f"Custom OpenAI API: Error response: {response.text}")
+            return f"OpenAI: Failed to process chat response. Status code: {response.status_code}"
+    except json.JSONDecodeError as e:
+        logging.error(f"Custom OpenAI API: Error decoding JSON: {str(e)}", exc_info=True)
+        return f"Custom OpenAI API: Error decoding JSON input: {str(e)}"
+    except requests.RequestException as e:
+        logging.error(f"Custom OpenAI API: Error making API request: {str(e)}", exc_info=True)
+        return f"Custom OpenAI API: Error making API request: {str(e)}"
+    except Exception as e:
+        logging.error(f"Custom OpenAI API: Unexpected error: {str(e)}", exc_info=True)
+        return f"Custom OpenAI API: Unexpected error occurred: {str(e)}"
 
 
 def save_summary_to_file(summary, file_path):