Upload 9 files

App_Function_Libraries/Chat.py

@@ -19,53 +19,89 @@ from App_Function_Libraries.LLM_API_Calls import chat_with_openai, chat_with_ant
 from App_Function_Libraries.LLM_API_Calls_Local import chat_with_aphrodite, chat_with_local_llm, chat_with_ollama, \
     chat_with_kobold, chat_with_llama, chat_with_oobabooga, chat_with_tabbyapi, chat_with_vllm, chat_with_custom_openai
 from App_Function_Libraries.DB.SQLite_DB import load_media_content
-from App_Function_Libraries.Utils.Utils import generate_unique_filename
+from App_Function_Libraries.Utils.Utils import generate_unique_filename, load_and_log_configs
+
+
 #
 ####################################################################################################
 #
 # Functions:
 
+
 def chat_api_call(api_endpoint, api_key, input_data, prompt, temp, system_message=None):
     if not api_key:
         api_key = None
+    model = None
     try:
         logging.info(f"Debug - Chat API Call - API Endpoint: {api_endpoint}")
         logging.info(f"Debug - Chat API Call - API Key: {api_key}")
         logging.info(f"Debug - Chat chat_api_call - API Endpoint: {api_endpoint}")
         if api_endpoint.lower() == 'openai':
             response = chat_with_openai(api_key, input_data, prompt, temp, system_message)
-        elif api_endpoint.lower() == "anthropic":
-            response = chat_with_anthropic(api_key, input_data, prompt, temp, system_message)
+
+        elif api_endpoint.lower() == 'anthropic':
+            # Retrieve the model from config
+            loaded_config_data = load_and_log_configs()
+            model = loaded_config_data['models']['anthropic'] if loaded_config_data else None
+            response = chat_with_anthropic(
+                api_key=api_key,
+                input_data=input_data,
+                model=model,
+                custom_prompt_arg=prompt,
+                system_prompt=system_message
+            )
+
         elif api_endpoint.lower() == "cohere":
-            response = chat_with_cohere(api_key, input_data, prompt, temp, system_message)
+            response = chat_with_cohere(
+                api_key,
+                input_data,
+                model=model,
+                custom_prompt_arg=prompt,
+                system_prompt=system_message,
+                temp=temp
+            )
+
         elif api_endpoint.lower() == "groq":
             response = chat_with_groq(api_key, input_data, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "openrouter":
             response = chat_with_openrouter(api_key, input_data, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "deepseek":
             response = chat_with_deepseek(api_key, input_data, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "mistral":
             response = chat_with_mistral(api_key, input_data, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "llama.cpp":
-            response = chat_with_llama(input_data, prompt, temp, system_message)
+            response = chat_with_llama(input_data, prompt, temp, None, api_key, system_message)
         elif api_endpoint.lower() == "kobold":
             response = chat_with_kobold(input_data, api_key, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "ooba":
             response = chat_with_oobabooga(input_data, api_key, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "tabbyapi":
             response = chat_with_tabbyapi(input_data, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "vllm":
             response = chat_with_vllm(input_data, prompt, system_message)
+
         elif api_endpoint.lower() == "local-llm":
             response = chat_with_local_llm(input_data, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "huggingface":
             response = chat_with_huggingface(api_key, input_data, prompt, temp)  # , system_message)
+
         elif api_endpoint.lower() == "ollama":
-            response = chat_with_ollama(input_data, prompt, temp, system_message)
+            response = chat_with_ollama(input_data, prompt, None, api_key, temp, system_message)
+
         elif api_endpoint.lower() == "aphrodite":
             response = chat_with_aphrodite(input_data, prompt, temp, system_message)
+
         elif api_endpoint.lower() == "custom-openai-api":
             response = chat_with_custom_openai(api_key, input_data, prompt, temp, system_message)
+
         else:
             raise ValueError(f"Unsupported API endpoint: {api_endpoint}")
 
@@ -97,12 +133,10 @@ def chat(message, history, media_content, selected_parts, api_endpoint, api_key,
         # logging.debug(f"Debug - Chat Function - Combined Content: {combined_content[:500]}...")
 
         # Prepare the input for the API
-        if not history:
-            input_data = f"{combined_content}\n\nUser: {message}\n"
-        else:
-            input_data = f"User: {message}\n"
-        # Print first 500 chars
-        # logging.info(f"Debug - Chat Function - Input Data: {input_data[:500]}...")
+        input_data = f"{combined_content}\n\n" if combined_content else ""
+        for old_message, old_response in history:
+            input_data += f"{old_message}\nAssistant: {old_response}\n\n"
+        input_data += f"{message}\n"
 
         if system_message:
             print(f"System message: {system_message}")
@@ -110,7 +144,7 @@ def chat(message, history, media_content, selected_parts, api_endpoint, api_key,
         temperature = float(temperature) if temperature else 0.7
         temp = temperature
 
-        logging.debug("Debug - Chat Function - Temperature: {temperature}")
+        logging.debug(f"Debug - Chat Function - Temperature: {temperature}")
         logging.debug(f"Debug - Chat Function - API Key: {api_key[:10]}")
         logging.debug(f"Debug - Chat Function - Prompt: {prompt}")
 
@@ -124,13 +158,13 @@ def chat(message, history, media_content, selected_parts, api_endpoint, api_key,
 
 
 
-def save_chat_history_to_db_wrapper(chatbot, conversation_id, media_content):
+def save_chat_history_to_db_wrapper(chatbot, conversation_id, media_content, media_name=None):
     logging.info(f"Attempting to save chat history. Media content type: {type(media_content)}")
     try:
         # Extract the media_id and media_name from the media_content
         media_id = None
-        media_name = None
         if isinstance(media_content, dict):
+            media_id = None
             logging.debug(f"Media content keys: {media_content.keys()}")
             if 'content' in media_content:
                 try:
@@ -168,7 +202,7 @@ def save_chat_history_to_db_wrapper(chatbot, conversation_id, media_content):
 
         # Generate a unique conversation name using media_id and current timestamp
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        conversation_name = f"Chat_{media_id}_{timestamp}"
+        conversation_name = f"{media_name}_{timestamp}"
 
         new_conversation_id = save_chat_history_to_database(chatbot, conversation_id, media_id, media_name,
                                                             conversation_name)

App_Function_Libraries/Chunk_Lib.py

@@ -32,8 +32,13 @@ from App_Function_Libraries.Utils.Utils import load_comprehensive_config
 #
 # FIXME - Make sure it only downloads if it already exists, and does a check first.
 # Ensure NLTK data is downloaded
-def ntlk_prep():
-    nltk.download('punkt')
+def ensure_nltk_data():
+    try:
+        nltk.data.find('tokenizers/punkt')
+    except LookupError:
+        nltk.download('punkt')
+ensure_nltk_data()
+
 #
 # Load GPT2 tokenizer
 tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
@@ -57,6 +62,34 @@ openai_api_key = config.get('API', 'openai_api_key')
 #
 # Functions:
 
+# Create a chunking class for refactoring FIXME
+# class Chunker:
+#     def __init__(self, tokenizer: GPT2Tokenizer):
+#         self.tokenizer = tokenizer
+#
+#     def detect_language(self, text: str) -> str:
+#         try:
+#             return detect(text)
+#         except:
+#             return 'en'
+#
+#     def chunk_text(self, text: str, method: str, max_size: int, overlap: int, language: str = None) -> List[str]:
+#         if language is None:
+#             language = self.detect_language(text)
+#
+#         if method == 'words':
+#             return self.chunk_text_by_words(text, max_size, overlap, language)
+#         elif method == 'sentences':
+#             return self.chunk_text_by_sentences(text, max_size, overlap, language)
+#         elif method == 'paragraphs':
+#             return self.chunk_text_by_paragraphs(text, max_size, overlap)
+#         elif method == 'tokens':
+#             return self.chunk_text_by_tokens(text, max_size, overlap, language)
+#         elif method == 'semantic':
+#             return self.semantic_chunking(text, max_size)
+#         else:
+#             return [text]
+
 def detect_language(text: str) -> str:
     try:
         return detect(text)
@@ -65,13 +98,13 @@ def detect_language(text: str) -> str:
         return 'en'
 
 
-def load_document(file_path):
-    with open(file_path, 'r') as file:
+def load_document(file_path: str) -> str:
+    with open(file_path, 'r', encoding='utf-8') as file:
         text = file.read()
-    return re.sub('\\s+', ' ', text).strip()
+    return re.sub(r'\s+', ' ', text).strip()
 
 
-def improved_chunking_process(text: str, custom_chunk_options: Dict[str, Any] = None) -> List[Dict[str, Any]]:
+def improved_chunking_process(text: str, chunk_options: Dict[str, Any] = None) -> List[Dict[str, Any]]:
     logging.debug("Improved chunking process started...")
 
     # Extract JSON metadata if present
@@ -92,9 +125,9 @@ def improved_chunking_process(text: str, custom_chunk_options: Dict[str, Any] =
         text = text[len(header_text):].strip()
         logging.debug(f"Extracted header text: {header_text}")
 
-    options = chunk_options.copy()
-    if custom_chunk_options:
-        options.update(custom_chunk_options)
+    options = chunk_options.copy() if chunk_options else {}
+    if chunk_options:
+        options.update(chunk_options)
 
     chunk_method = options.get('method', 'words')
     max_size = options.get('max_size', 2000)
@@ -104,32 +137,39 @@ def improved_chunking_process(text: str, custom_chunk_options: Dict[str, Any] =
     if language is None:
         language = detect_language(text)
 
-    chunks = chunk_text(text, chunk_method, max_size, overlap, language)
+    if chunk_method == 'json':
+        chunks = chunk_text_by_json(text, max_size=max_size, overlap=overlap)
+    else:
+        chunks = chunk_text(text, chunk_method, max_size, overlap, language)
 
     chunks_with_metadata = []
     total_chunks = len(chunks)
     for i, chunk in enumerate(chunks):
         metadata = {
-            'chunk_index': i,
+            'chunk_index': i + 1,
             'total_chunks': total_chunks,
             'chunk_method': chunk_method,
             'max_size': max_size,
             'overlap': overlap,
             'language': language,
-            'relative_position': i / total_chunks
+            'relative_position': (i + 1) / total_chunks
         }
         metadata.update(json_content)  # Add the extracted JSON content to metadata
         metadata['header_text'] = header_text  # Add the header text to metadata
 
+        if chunk_method == 'json':
+            chunk_text_content = json.dumps(chunk['json'], ensure_ascii=False)
+        else:
+            chunk_text_content = chunk
+
         chunks_with_metadata.append({
-            'text': chunk,
+            'text': chunk_text_content,
             'metadata': metadata
         })
 
     return chunks_with_metadata
 
 
-
 def multi_level_chunking(text: str, method: str, max_size: int, overlap: int, language: str) -> List[str]:
     logging.debug("Multi-level chunking process started...")
     # First level: chunk by paragraphs
@@ -139,35 +179,34 @@ def multi_level_chunking(text: str, method: str, max_size: int, overlap: int, la
     chunks = []
     for para in paragraphs:
         if method == 'words':
-            chunks.extend(chunk_text_by_words(para, max_size, overlap, language))
+            chunks.extend(chunk_text_by_words(para, max_words=max_size, overlap=overlap, language=language))
         elif method == 'sentences':
-            chunks.extend(chunk_text_by_sentences(para, max_size, overlap, language))
+            chunks.extend(chunk_text_by_sentences(para, max_sentences=max_size, overlap=overlap, language=language))
         else:
             chunks.append(para)
 
     return chunks
 
 
-
 # FIXME - ensure language detection occurs in each chunk function
-def chunk_text(text: str, method: str, max_size: int, overlap: int, language: str=None) -> List[str]:
-
+def chunk_text(text: str, method: str, max_size: int, overlap: int, language: str = None) -> List[str]:
     if method == 'words':
         logging.debug("Chunking by words...")
-        return chunk_text_by_words(text, max_size, overlap, language)
+        return chunk_text_by_words(text, max_words=max_size, overlap=overlap, language=language)
     elif method == 'sentences':
         logging.debug("Chunking by sentences...")
-        return chunk_text_by_sentences(text, max_size, overlap, language)
+        return chunk_text_by_sentences(text, max_sentences=max_size, overlap=overlap, language=language)
     elif method == 'paragraphs':
         logging.debug("Chunking by paragraphs...")
-        return chunk_text_by_paragraphs(text, max_size, overlap)
+        return chunk_text_by_paragraphs(text, max_paragraphs=max_size, overlap=overlap)
     elif method == 'tokens':
         logging.debug("Chunking by tokens...")
-        return chunk_text_by_tokens(text, max_size, overlap)
+        return chunk_text_by_tokens(text, max_tokens=max_size, overlap=overlap)
     elif method == 'semantic':
         logging.debug("Chunking by semantic similarity...")
-        return semantic_chunking(text, max_size)
+        return semantic_chunking(text, max_chunk_size=max_size)
     else:
+        logging.warning(f"Unknown chunking method '{method}'. Returning full text as a single chunk.")
         return [text]
 
 def determine_chunk_position(relative_position: float) -> str:
@@ -206,22 +245,37 @@ def chunk_text_by_sentences(text: str, max_sentences: int = 10, overlap: int = 0
     if language is None:
         language = detect_language(text)
 
-    nltk.download('punkt', quiet=True)
-
     if language.startswith('zh'):  # Chinese
         import jieba
-        sentences = list(jieba.cut(text, cut_all=False))
+        # Use jieba to perform sentence segmentation
+        # jieba does not support sentence segmentation out of the box
+        # Use punctuation as delimiters
+        sentences = re.split(r'[。！？；]', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
     elif language == 'ja':  # Japanese
         import fugashi
         tagger = fugashi.Tagger()
-        sentences = [word.surface for word in tagger(text) if word.feature.pos1 in ['記号', '補助記号'] and word.surface.strip()]
+        # Simple sentence segmentation based on punctuation
+        sentences = re.split(r'[。！？]', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
     else:  # Default to NLTK for other languages
-        sentences = sent_tokenize(text, language=language)
+        try:
+            sentences = sent_tokenize(text, language=language)
+        except LookupError:
+            logging.warning(f"Punkt tokenizer not found for language '{language}'. Using default 'english'.")
+            sentences = sent_tokenize(text, language='english')
 
     chunks = []
+    previous_overlap = []
+
     for i in range(0, len(sentences), max_sentences - overlap):
-        chunk = ' '.join(sentences[i:i + max_sentences])
+        current_sentences = sentences[i:i + max_sentences]
+        if overlap > 0 and previous_overlap:
+            current_sentences = previous_overlap + current_sentences
+        chunk = ' '.join(current_sentences)
         chunks.append(chunk)
+        previous_overlap = sentences[i + max_sentences - overlap:i + max_sentences] if overlap > 0 else []
+
     return post_process_chunks(chunks)
 
 
@@ -258,6 +312,16 @@ def chunk_text_by_tokens(text: str, max_tokens: int = 1000, overlap: int = 0) ->
         chunks.append(' '.join(current_chunk))
 
     return post_process_chunks(chunks)
+# def chunk_text_by_tokens(text: str, max_tokens: int = 1000, overlap: int = 0) -> List[str]:
+#     logging.debug("chunk_text_by_tokens...")
+#     # Use GPT2 tokenizer for tokenization
+#     tokens = tokenizer.encode(text)
+#     chunks = []
+#     for i in range(0, len(tokens), max_tokens - overlap):
+#         chunk_tokens = tokens[i:i + max_tokens]
+#         chunk = tokenizer.decode(chunk_tokens)
+#         chunks.append(chunk)
+#     return post_process_chunks(chunks)
 
 
 def post_process_chunks(chunks: List[str]) -> List[str]:
@@ -266,35 +330,35 @@ def post_process_chunks(chunks: List[str]) -> List[str]:
 
 # FIXME - F
 def get_chunk_metadata(chunk: str, full_text: str, chunk_type: str = "generic",
-                       chapter_number: Optional[int] = None,
-                       chapter_pattern: Optional[str] = None,
-                       language: str = None) -> Dict[str, Any]:
-    try:
-        logging.debug("get_chunk_metadata...")
-        start_index = full_text.index(chunk)
-        end_index = start_index + len(chunk)
-        # Calculate a hash for the chunk
-        chunk_hash = hashlib.md5(chunk.encode()).hexdigest()
-
-        metadata = {
-            'start_index': start_index,
-            'end_index': end_index,
-            'word_count': len(chunk.split()),
-            'char_count': len(chunk),
-            'chunk_type': chunk_type,
-            'language': language,
-            'chunk_hash': chunk_hash,
-            'relative_position': start_index / len(full_text)
-        }
+                      chapter_number: Optional[int] = None,
+                      chapter_pattern: Optional[str] = None,
+                      language: str = None) -> Dict[str, Any]:
+    """
+    Generate metadata for a chunk based on its position in the full text.
+    """
+    chunk_length = len(chunk)
+    start_index = full_text.find(chunk)
+    end_index = start_index + chunk_length if start_index != -1 else None
+
+    # Calculate a hash for the chunk
+    chunk_hash = hashlib.md5(chunk.encode()).hexdigest()
+
+    metadata = {
+        'start_index': start_index,
+        'end_index': end_index,
+        'word_count': len(chunk.split()),
+        'char_count': chunk_length,
+        'chunk_type': chunk_type,
+        'language': language,
+        'chunk_hash': chunk_hash,
+        'relative_position': start_index / len(full_text) if len(full_text) > 0 and start_index != -1 else 0
+    }
 
-        if chunk_type == "chapter":
-            metadata['chapter_number'] = chapter_number
-            metadata['chapter_pattern'] = chapter_pattern
+    if chunk_type == "chapter":
+        metadata['chapter_number'] = chapter_number
+        metadata['chapter_pattern'] = chapter_pattern
 
-        return metadata
-    except ValueError as e:
-        logging.error(f"Chunk not found in full_text: {chunk[:50]}... Full text length: {len(full_text)}")
-        raise
+    return metadata
 
 
 def process_document_with_metadata(text: str, chunk_options: Dict[str, Any],
@@ -308,27 +372,33 @@ def process_document_with_metadata(text: str, chunk_options: Dict[str, Any],
 
 
 # Hybrid approach, chunk each sentence while ensuring total token size does not exceed a maximum number
-def chunk_text_hybrid(text, max_tokens=1000):
+def chunk_text_hybrid(text: str, max_tokens: int = 1000, overlap: int = 0) -> List[str]:
     logging.debug("chunk_text_hybrid...")
-    sentences = nltk.tokenize.sent_tokenize(text)
+    sentences = sent_tokenize(text)
     chunks = []
     current_chunk = []
     current_length = 0
 
     for sentence in sentences:
         tokens = tokenizer.encode(sentence)
-        if current_length + len(tokens) <= max_tokens:
-            current_chunk.append(sentence)
-            current_length += len(tokens)
-        else:
+        if current_length + len(tokens) > max_tokens and current_chunk:
             chunks.append(' '.join(current_chunk))
-            current_chunk = [sentence]
-            current_length = len(tokens)
+            # Handle overlap
+            if overlap > 0:
+                overlap_tokens = tokenizer.encode(' '.join(current_chunk[-overlap:]))
+                current_chunk = current_chunk[-overlap:]
+                current_length = len(overlap_tokens)
+            else:
+                current_chunk = []
+                current_length = 0
+
+        current_chunk.append(sentence)
+        current_length += len(tokens)
 
     if current_chunk:
         chunks.append(' '.join(current_chunk))
 
-    return chunks
+    return post_process_chunks(chunks)
 
 
 # Thanks openai
@@ -340,21 +410,22 @@ def chunk_on_delimiter(input_string: str,
     combined_chunks, _, dropped_chunk_count = combine_chunks_with_no_minimum(
         chunks, max_tokens, chunk_delimiter=delimiter, add_ellipsis_for_overflow=True)
     if dropped_chunk_count > 0:
-        print(f"Warning: {dropped_chunk_count} chunks were dropped due to exceeding the token limit.")
+        logging.warning(f"Warning: {dropped_chunk_count} chunks were dropped due to exceeding the token limit.")
     combined_chunks = [f"{chunk}{delimiter}" for chunk in combined_chunks]
     return combined_chunks
 
 
 
 
-# ????FIXME
-def recursive_summarize_chunks(chunks, summarize_func, custom_prompt, temp=None, system_prompt=None):
+# FIXME
+def recursive_summarize_chunks(chunks: List[str], summarize_func, custom_prompt: Optional[str] = None,
+                               temp: Optional[float] = None, system_prompt: Optional[str] = None) -> List[str]:
     logging.debug("recursive_summarize_chunks...")
     summarized_chunks = []
     current_summary = ""
 
-    logging.debug(f"recursive_summarize_chunks: Summarizing {len(chunks)} chunks recursively...")
-    logging.debug(f"recursive_summarize_chunks:  temperature is @ {temp}")
+    logging.debug(f"Summarizing {len(chunks)} chunks recursively...")
+    logging.debug(f"Temperature is set to {temp}")
     for i, chunk in enumerate(chunks):
         if i == 0:
             current_summary = summarize_func(chunk, custom_prompt, temp, system_prompt)
@@ -406,20 +477,20 @@ Natural language processing has its roots in the 1950s. Already in 1950, Alan Tu
 #
 
 # Chunk text into segments based on semantic similarity
-def count_units(text, unit='words'):
+def count_units(text: str, unit: str = 'words') -> int:
     if unit == 'words':
         return len(text.split())
     elif unit == 'tokens':
-        return len(word_tokenize(text))
+        return len(tokenizer.encode(text))
     elif unit == 'characters':
         return len(text)
     else:
         raise ValueError("Invalid unit. Choose 'words', 'tokens', or 'characters'.")
 
 
-def semantic_chunking(text, max_chunk_size=2000, unit='words'):
+
+def semantic_chunking(text: str, max_chunk_size: int = 2000, unit: str = 'words') -> List[str]:
     logging.debug("semantic_chunking...")
-    nltk.download('punkt', quiet=True)
     sentences = sent_tokenize(text)
     vectorizer = TfidfVectorizer()
     sentence_vectors = vectorizer.fit_transform(sentences)
@@ -432,9 +503,9 @@ def semantic_chunking(text, max_chunk_size=2000, unit='words'):
         sentence_size = count_units(sentence, unit)
         if current_size + sentence_size > max_chunk_size and current_chunk:
             chunks.append(' '.join(current_chunk))
-            overlap_size = count_units(' '.join(current_chunk[-3:]), unit)  # Use last 3 sentences for overlap
-            current_chunk = current_chunk[-3:]  # Keep last 3 sentences for overlap
-            current_size = overlap_size
+            # Use last 3 sentences for overlap
+            current_chunk = current_chunk[-3:]
+            current_size = count_units(' '.join(current_chunk), unit)
 
         current_chunk.append(sentence)
         current_size += sentence_size
@@ -445,9 +516,8 @@ def semantic_chunking(text, max_chunk_size=2000, unit='words'):
             similarity = cosine_similarity(current_vector, next_vector)[0][0]
             if similarity < 0.5 and current_size >= max_chunk_size // 2:
                 chunks.append(' '.join(current_chunk))
-                overlap_size = count_units(' '.join(current_chunk[-3:]), unit)
                 current_chunk = current_chunk[-3:]
-                current_size = overlap_size
+                current_size = count_units(' '.join(current_chunk), unit)
 
     if current_chunk:
         chunks.append(' '.join(current_chunk))
@@ -455,7 +525,7 @@ def semantic_chunking(text, max_chunk_size=2000, unit='words'):
     return chunks
 
 
-def semantic_chunk_long_file(file_path, max_chunk_size=1000, overlap=100, unit='words'):
+def semantic_chunk_long_file(file_path: str, max_chunk_size: int = 1000, overlap: int = 100, unit: str = 'words') -> Optional[List[str]]:
     logging.debug("semantic_chunk_long_file...")
     try:
         with open(file_path, 'r', encoding='utf-8') as file:
@@ -510,6 +580,162 @@ def chunk_for_embedding(text: str, file_name: str, custom_chunk_options: Dict[st
 #######################################################################################################################
 
 
+#######################################################################################################################
+#
+# JSON Chunking
+
+# FIXME
+def chunk_text_by_json(text: str, max_size: int = 1000, overlap: int = 0) -> List[Dict[str, Any]]:
+    """
+    Chunk JSON-formatted text into smaller JSON chunks while preserving structure.
+
+    Parameters:
+        - text (str): The JSON-formatted text to be chunked.
+        - max_size (int): Maximum number of items or characters per chunk.
+        - overlap (int): Number of items or characters to overlap between chunks.
+
+    Returns:
+        - List[Dict[str, Any]]: A list of chunks with their metadata.
+    """
+    logging.debug("chunk_text_by_json started...")
+    try:
+        json_data = json.loads(text)
+    except json.JSONDecodeError as e:
+        logging.error(f"Invalid JSON data: {e}")
+        raise ValueError(f"Invalid JSON data: {e}")
+
+    # Determine if JSON data is a list or a dict
+    if isinstance(json_data, list):
+        return chunk_json_list(json_data, max_size, overlap)
+    elif isinstance(json_data, dict):
+        return chunk_json_dict(json_data, max_size, overlap)
+    else:
+        logging.error("Unsupported JSON structure. Only JSON objects and arrays are supported.")
+        raise ValueError("Unsupported JSON structure. Only JSON objects and arrays are supported.")
+
+
+def chunk_json_list(json_list: List[Any], max_size: int, overlap: int) -> List[Dict[str, Any]]:
+    """
+    Chunk a JSON array into smaller chunks.
+
+    Parameters:
+        - json_list (List[Any]): The JSON array to be chunked.
+        - max_size (int): Maximum number of items per chunk.
+        - overlap (int): Number of items to overlap between chunks.
+
+    Returns:
+        - List[Dict[str, Any]]: A list of JSON chunks with metadata.
+    """
+    logging.debug("chunk_json_list started...")
+    chunks = []
+    total_items = len(json_list)
+    step = max_size - overlap
+    if step <= 0:
+        raise ValueError("max_size must be greater than overlap.")
+
+    for i in range(0, total_items, step):
+        chunk = json_list[i:i + max_size]
+        metadata = {
+            'chunk_index': i // step + 1,
+            'total_chunks': (total_items + step - 1) // step,
+            'chunk_method': 'json_list',
+            'max_size': max_size,
+            'overlap': overlap,
+            'relative_position': i / total_items
+        }
+        chunks.append({
+            'json': chunk,
+            'metadata': metadata
+        })
+
+    logging.debug(f"chunk_json_list created {len(chunks)} chunks.")
+    return chunks
+
+
+
+def chunk_json_dict(json_dict: Dict[str, Any], max_size: int, overlap: int) -> List[Dict[str, Any]]:
+    """
+    Chunk a JSON object into smaller chunks based on its 'data' key while preserving other keys like 'metadata'.
+
+    Parameters:
+        - json_dict (Dict[str, Any]): The JSON object to be chunked.
+        - max_size (int): Maximum number of key-value pairs per chunk in the 'data' section.
+        - overlap (int): Number of key-value pairs to overlap between chunks.
+
+    Returns:
+        - List[Dict[str, Any]]: A list of JSON chunks with metadata.
+    """
+    logging.debug("chunk_json_dict started...")
+
+    # Preserve non-chunked sections
+    preserved_keys = ['metadata']
+    preserved_data = {key: value for key, value in json_dict.items() if key in preserved_keys}
+
+    # Identify the chunkable section
+    chunkable_key = 'data'
+    if chunkable_key not in json_dict or not isinstance(json_dict[chunkable_key], dict):
+        logging.error("No chunkable 'data' section found in JSON dictionary.")
+        raise ValueError("No chunkable 'data' section found in JSON dictionary.")
+
+    chunkable_data = json_dict[chunkable_key]
+    data_keys = list(chunkable_data.keys())
+    total_keys = len(data_keys)
+    chunks = []
+    step = max_size - overlap
+    if step <= 0:
+        raise ValueError("max_size must be greater than overlap.")
+
+    # Adjust the loop to prevent creating an extra chunk
+    for i in range(0, total_keys, step):
+        chunk_keys = data_keys[i:i + max_size]
+
+        # Handle overlap
+        if i != 0 and overlap > 0:
+            overlap_keys = data_keys[i - overlap:i]
+            chunk_keys = overlap_keys + chunk_keys
+
+        # Remove duplicate keys caused by overlap
+        unique_chunk_keys = []
+        seen_keys = set()
+        for key in chunk_keys:
+            if key not in seen_keys:
+                unique_chunk_keys.append(key)
+                seen_keys.add(key)
+
+        chunk_data = {key: chunkable_data[key] for key in unique_chunk_keys}
+
+        metadata = {
+            'chunk_index': (i // step) + 1,
+            'total_chunks': (total_keys + step - 1) // step,
+            'chunk_method': 'json_dict',
+            'max_size': max_size,
+            'overlap': overlap,
+            'language': 'english',  # Assuming English; modify as needed
+            'relative_position': (i // step + 1) / ((total_keys + step - 1) // step)
+        }
+
+        # Merge preserved data into metadata
+        metadata.update(preserved_data.get('metadata', {}))
+
+        # Create the chunk with preserved data
+        chunk = {
+            'metadata': preserved_data,
+            'data': chunk_data
+        }
+
+        chunks.append({
+            'json': chunk,
+            'metadata': metadata
+        })
+
+    logging.debug(f"chunk_json_dict created {len(chunks)} chunks.")
+    return chunks
+
+
+#
+# End of JSON Chunking
+#######################################################################################################################
+
 #######################################################################################################################
 #
 # OpenAI Rolling Summarization
@@ -530,45 +756,38 @@ def get_chat_completion(messages, model='gpt-4-turbo'):
 def combine_chunks_with_no_minimum(
         chunks: List[str],
         max_tokens: int,
-        chunk_delimiter="\n\n",
+        chunk_delimiter: str = "\n\n",
         header: Optional[str] = None,
-        add_ellipsis_for_overflow=False,
+        add_ellipsis_for_overflow: bool = False,
 ) -> Tuple[List[str], List[List[int]], int]:
     dropped_chunk_count = 0
     output = []  # list to hold the final combined chunks
     output_indices = []  # list to hold the indices of the final combined chunks
-    candidate = (
-        [] if header is None else [header]
-    )  # list to hold the current combined chunk candidate
+    candidate = [header] if header else []  # list to hold the current combined chunk candidate
     candidate_indices = []
     for chunk_i, chunk in enumerate(chunks):
-        chunk_with_header = [chunk] if header is None else [header, chunk]
-        # FIXME MAKE NOT OPENAI SPECIFIC
-        if len(openai_tokenize(chunk_delimiter.join(chunk_with_header))) > max_tokens:
-            print(f"warning: chunk overflow")
-            if (
-                    add_ellipsis_for_overflow
-                    # FIXME MAKE NOT OPENAI SPECIFIC
-                    and len(openai_tokenize(chunk_delimiter.join(candidate + ["..."]))) <= max_tokens
-            ):
-                candidate.append("...")
+        chunk_with_header = [chunk] if not header else [header, chunk]
+        combined_text = chunk_delimiter.join(candidate + chunk_with_header)
+        token_count = len(tokenizer.encode(combined_text))
+        if token_count > max_tokens:
+            if add_ellipsis_for_overflow and len(candidate) > 0:
+                ellipsis_text = chunk_delimiter.join(candidate + ["..."])
+                if len(tokenizer.encode(ellipsis_text)) <= max_tokens:
+                    candidate = candidate + ["..."]
+                    dropped_chunk_count += 1
+            if len(candidate) > 0:
+                output.append(chunk_delimiter.join(candidate))
+                output_indices.append(candidate_indices)
+                candidate = chunk_with_header
+                candidate_indices = [chunk_i]
+            else:
+                logging.warning(f"Single chunk at index {chunk_i} exceeds max_tokens and will be dropped.")
                 dropped_chunk_count += 1
-            continue  # this case would break downstream assumptions
-        # estimate token count with the current chunk added
-        # FIXME MAKE NOT OPENAI SPECIFIC
-        extended_candidate_token_count = len(openai_tokenize(chunk_delimiter.join(candidate + [chunk])))
-        # If the token count exceeds max_tokens, add the current candidate to output and start a new candidate
-        if extended_candidate_token_count > max_tokens:
-            output.append(chunk_delimiter.join(candidate))
-            output_indices.append(candidate_indices)
-            candidate = chunk_with_header  # re-initialize candidate
-            candidate_indices = [chunk_i]
-        # otherwise keep extending the candidate
         else:
-            candidate.append(chunk)
+            candidate.extend(chunk_with_header)
             candidate_indices.append(chunk_i)
-    # add the remaining candidate to output if it's not empty
-    if (header is not None and len(candidate) > 1) or (header is None and len(candidate) > 0):
+
+    if candidate:
         output.append(chunk_delimiter.join(candidate))
         output_indices.append(candidate_indices)
     return output, output_indices, dropped_chunk_count
@@ -576,27 +795,25 @@ def combine_chunks_with_no_minimum(
 
 def rolling_summarize(text: str,
                       detail: float = 0,
-                      model: str = 'gpt-4-turbo',
+                      model: str = 'gpt-4o',
                       additional_instructions: Optional[str] = None,
                       minimum_chunk_size: Optional[int] = 500,
                       chunk_delimiter: str = ".",
-                      summarize_recursively=False,
-                      verbose=False):
+                      summarize_recursively: bool = False,
+                      verbose: bool = False) -> str:
     """
     Summarizes a given text by splitting it into chunks, each of which is summarized individually.
     The level of detail in the summary can be adjusted, and the process can optionally be made recursive.
 
     Parameters:
         - text (str): The text to be summarized.
-        - detail (float, optional): A value between 0 and 1
-            indicating the desired level of detail in the summary. 0 leads to a higher level summary, and 1 results in a more
-            detailed summary. Defaults to 0.
-        - additional_instructions (Optional[str], optional): Additional instructions to provide to the
-            model for customizing summaries. - minimum_chunk_size (Optional[int], optional): The minimum size for text
-            chunks. Defaults to 500.
-        - chunk_delimiter (str, optional): The delimiter used to split the text into chunks. Defaults to ".".
-        - summarize_recursively (bool, optional): If True, summaries are generated recursively, using previous summaries for context.
+        - detail (float, optional): A value between 0 and 1 indicating the desired level of detail in the summary.
+        - additional_instructions (Optional[str], optional): Additional instructions for the model.
+        - minimum_chunk_size (Optional[int], optional): The minimum size for text chunks.
+        - chunk_delimiter (str, optional): The delimiter used to split the text into chunks.
+        - summarize_recursively (bool, optional): If True, summaries are generated recursively.
         - verbose (bool, optional): If True, prints detailed information about the chunking process.
+
     Returns:
     - str: The final compiled summary of the text.
 
@@ -606,31 +823,29 @@ def rolling_summarize(text: str,
     summarization process. The function returns a compiled summary of all chunks.
     """
 
-    # check detail is set correctly
-    assert 0 <= detail <= 1
+    # Check detail is set correctly
+    assert 0 <= detail <= 1, "Detail must be between 0 and 1."
 
-    # interpolate the number of chunks based to get specified level of detail
-    max_chunks = len(chunk_on_delimiter(text, minimum_chunk_size, chunk_delimiter))
+    # Interpolate the number of chunks based on the detail parameter
+    text_length = len(tokenizer.encode(text))
+    max_chunks = text_length // minimum_chunk_size if minimum_chunk_size else 10
     min_chunks = 1
     num_chunks = int(min_chunks + detail * (max_chunks - min_chunks))
 
-    # adjust chunk_size based on interpolated number of chunks
-    # FIXME MAKE NOT OPENAI SPECIFIC
-    document_length = len(openai_tokenize(text))
-    chunk_size = max(minimum_chunk_size, document_length // num_chunks)
+    # Adjust chunk_size based on interpolated number of chunks
+    chunk_size = max(minimum_chunk_size, text_length // num_chunks) if num_chunks else text_length
     text_chunks = chunk_on_delimiter(text, chunk_size, chunk_delimiter)
     if verbose:
         print(f"Splitting the text into {len(text_chunks)} chunks to be summarized.")
-        # FIXME MAKE NOT OPENAI SPECIFIC
-        print(f"Chunk lengths are {[len(openai_tokenize(x)) for x in text_chunks]}")
+        print(f"Chunk lengths are {[len(tokenizer.encode(x)) for x in text_chunks]} tokens.")
 
-    # set system message - FIXME
+    # Set system message
     system_message_content = "Rewrite this text in summarized form."
-    if additional_instructions is not None:
+    if additional_instructions:
         system_message_content += f"\n\n{additional_instructions}"
 
     accumulated_summaries = []
-    for i, chunk in enumerate(tqdm(text_chunks)):
+    for i, chunk in enumerate(tqdm(text_chunks, desc="Summarizing chunks")):
         if summarize_recursively and accumulated_summaries:
             # Combine previous summary with current chunk for recursive summarization
             combined_text = accumulated_summaries[-1] + "\n\n" + chunk
@@ -658,8 +873,8 @@ def rolling_summarize(text: str,
 
 def chunk_ebook_by_chapters(text: str, chunk_options: Dict[str, Any]) -> List[Dict[str, Any]]:
     logging.debug("chunk_ebook_by_chapters")
-    max_chunk_size = chunk_options.get('max_size', 300)
-    overlap = chunk_options.get('overlap', 0)
+    max_chunk_size = int(chunk_options.get('max_size', 300))
+    overlap = int(chunk_options.get('overlap', 0))
     custom_pattern = chunk_options.get('custom_chapter_pattern', None)
 
     # List of chapter heading patterns to try, in order
@@ -685,7 +900,13 @@ def chunk_ebook_by_chapters(text: str, chunk_options: Dict[str, Any]) -> List[Di
 
     # If no chapters found, return the entire content as one chunk
     if not chapter_positions:
-        return [{'text': text, 'metadata': get_chunk_metadata(text, text, chunk_type="whole_document")}]
+        metadata = get_chunk_metadata(
+            chunk=text,
+            full_text=text,
+            chunk_type="whole_document",
+            language=chunk_options.get('language', 'english')
+        )
+        return [{'text': text, 'metadata': metadata}]
 
     # Split content into chapters
     chunks = []
@@ -696,7 +917,7 @@ def chunk_ebook_by_chapters(text: str, chunk_options: Dict[str, Any]) -> List[Di
 
         # Apply overlap if specified
         if overlap > 0 and i > 0:
-            overlap_start = max(0, start - overlap)
+            overlap_start = max(0, chapter_positions[i] - overlap)
             chapter = text[overlap_start:end]
 
         chunks.append(chapter)
@@ -705,52 +926,19 @@ def chunk_ebook_by_chapters(text: str, chunk_options: Dict[str, Any]) -> List[Di
     processed_chunks = post_process_chunks(chunks)
 
     # Add metadata to chunks
-    return [{'text': chunk, 'metadata': get_chunk_metadata(chunk, text, chunk_type="chapter", chapter_number=i + 1,
-                                                           chapter_pattern=used_pattern)}
-            for i, chunk in enumerate(processed_chunks)]
-
+    chunks_with_metadata = []
+    for i, chunk in enumerate(processed_chunks):
+        metadata = get_chunk_metadata(
+            chunk=chunk,
+            full_text=text,
+            chunk_type="chapter",
+            chapter_number=i + 1,
+            chapter_pattern=used_pattern,
+            language=chunk_options.get('language', 'english')
+        )
+        chunks_with_metadata.append({'text': chunk, 'metadata': metadata})
 
-# # Example usage
-# if __name__ == "__main__":
-#     sample_ebook_content = """
-# # Chapter 1: Introduction
-#
-# This is the introduction.
-#
-# ## Section 1.1
-#
-# Some content here.
-#
-# # Chapter 2: Main Content
-#
-# This is the main content.
-#
-# ## Section 2.1
-#
-# More content here.
-#
-# CHAPTER THREE
-#
-# This is the third chapter.
-#
-# 4. Fourth Chapter
-#
-# This is the fourth chapter.
-# """
-#
-#     chunk_options = {
-#         'method': 'chapters',
-#         'max_size': 500,
-#         'overlap': 50,
-#         'custom_chapter_pattern': r'^CHAPTER\s+[A-Z]+'  # Custom pattern for 'CHAPTER THREE' style
-#     }
-#
-#     chunked_chapters = improved_chunking_process(sample_ebook_content, chunk_options)
-#
-#     for i, chunk in enumerate(chunked_chapters, 1):
-#         print(f"Chunk {i}:")
-#         print(chunk['text'])
-#         print(f"Metadata: {chunk['metadata']}\n")
+    return chunks_with_metadata
 
 #
 # End of ebook chapter chunking
@@ -761,13 +949,14 @@ def chunk_ebook_by_chapters(text: str, chunk_options: Dict[str, Any]) -> List[Di
 # Functions for adapative chunking:
 
 # FIXME - punkt
-def adaptive_chunk_size(text: str, base_size: int = 1000, min_size: int = 500, max_size: int = 2000) -> int:
-    # Ensure NLTK data is downloaded
-    nltk.download('punkt', quiet=True)
 
+def adaptive_chunk_size(text: str, base_size: int = 1000, min_size: int = 500, max_size: int = 2000) -> int:
     # Tokenize the text into sentences
     sentences = sent_tokenize(text)
 
+    if not sentences:
+        return base_size
+
     # Calculate average sentence length
     avg_sentence_length = sum(len(s.split()) for s in sentences) / len(sentences)
 

App_Function_Libraries/LLM_API_Calls.py

@@ -1,966 +1,1109 @@
-# Summarization_General_Lib.py
-#########################################
-# General Summarization Library
-# This library is used to perform summarization.
-#
-####
-####################
-# Function List
-#
-# 1. extract_text_from_segments(segments: List[Dict]) -> str
-# 2. chat_with_openai(api_key, file_path, custom_prompt_arg)
-# 3. chat_with_anthropic(api_key, file_path, model, custom_prompt_arg, max_retries=3, retry_delay=5)
-# 4. chat_with_cohere(api_key, file_path, model, custom_prompt_arg)
-# 5. chat_with_groq(api_key, input_data, custom_prompt_arg, system_prompt=None):
-# 6. chat_with_openrouter(api_key, input_data, custom_prompt_arg, system_prompt=None)
-# 7. chat_with_huggingface(api_key, input_data, custom_prompt_arg, system_prompt=None)
-# 8. chat_with_deepseek(api_key, input_data, custom_prompt_arg, system_prompt=None)
-# 9. 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)
-#
-#
-####################
-#
-# Import necessary libraries
-import json
-import logging
-import os
-import time
-from typing import List
-
-import requests
-#
-# Import 3rd-Party Libraries
-from requests import RequestException
-#
-# Import Local libraries
-from App_Function_Libraries.Utils.Utils import load_and_log_configs
-#
-#######################################################################################################################
-# Function Definitions
-#
-
-#FIXME: Update to include full arguments
-
-def extract_text_from_segments(segments):
-    logging.debug(f"Segments received: {segments}")
-    logging.debug(f"Type of segments: {type(segments)}")
-
-    text = ""
-
-    if isinstance(segments, list):
-        for segment in segments:
-            logging.debug(f"Current segment: {segment}")
-            logging.debug(f"Type of segment: {type(segment)}")
-            if 'Text' in segment:
-                text += segment['Text'] + " "
-            else:
-                logging.warning(f"Skipping segment due to missing 'Text' key: {segment}")
-    else:
-        logging.warning(f"Unexpected type of 'segments': {type(segments)}")
-
-    return text.strip()
-
-
-
-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 not openai_api_key:
-            logging.info("OpenAI: API key not provided as parameter")
-            logging.info("OpenAI: Attempting to use API key from config file")
-            openai_api_key = loaded_config_data['api_keys']['openai']
-
-        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: {openai_api_key[:5]}...{openai_api_key[-5:]}")
-
-        # Input data handling
-        logging.debug(f"OpenAI: Raw input data type: {type(input_data)}")
-        logging.debug(f"OpenAI: 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("OpenAI: Parsing provided JSON string data for summarization")
-                try:
-                    data = json.loads(input_data)
-                except json.JSONDecodeError as e:
-                    logging.error(f"OpenAI: Error parsing JSON string: {str(e)}")
-                    return f"OpenAI: Error parsing JSON input: {str(e)}"
-            elif os.path.isfile(input_data):
-                logging.debug("OpenAI: Loading JSON data from file for summarization")
-                with open(input_data, 'r') as file:
-                    data = json.load(file)
-            else:
-                logging.debug("OpenAI: Using provided string data for summarization")
-                data = input_data
-        else:
-            data = input_data
-
-        logging.debug(f"OpenAI: Processed data type: {type(data)}")
-        logging.debug(f"OpenAI: Processed data (first 500 chars): {str(data)[:500]}...")
-
-        # Text extraction
-        if isinstance(data, dict):
-            if 'summary' in data:
-                logging.debug("OpenAI: 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"OpenAI: Invalid input data format: {type(data)}")
-
-        logging.debug(f"OpenAI: Extracted text (first 500 chars): {text[:500]}...")
-        logging.debug(f"OpenAI: Custom prompt: {custom_prompt_arg}")
-
-        openai_model = loaded_config_data['models']['openai'] or "gpt-4o"
-        logging.debug(f"OpenAI: Using model: {openai_model}")
-
-        headers = {
-            'Authorization': f'Bearer {openai_api_key}',
-            'Content-Type': 'application/json'
-        }
-
-        logging.debug(
-            f"OpenAI API Key: {openai_api_key[:5]}...{openai_api_key[-5:] if openai_api_key else None}")
-        logging.debug("openai: 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
-        }
-
-        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")
-                return "openai: Chat not available"
-        else:
-            logging.error(f"OpenAI: Chat request failed with status code {response.status_code}")
-            logging.error(f"OpenAI: 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"OpenAI: Error decoding JSON: {str(e)}", exc_info=True)
-        return f"OpenAI: Error decoding JSON input: {str(e)}"
-    except requests.RequestException as e:
-        logging.error(f"OpenAI: Error making API request: {str(e)}", exc_info=True)
-        return f"OpenAI: Error making API request: {str(e)}"
-    except Exception as e:
-        logging.error(f"OpenAI: Unexpected error: {str(e)}", exc_info=True)
-        return f"OpenAI: Unexpected error occurred: {str(e)}"
-
-
-def chat_with_anthropic(api_key, input_data, model, custom_prompt_arg, max_retries=3, retry_delay=5, system_prompt=None):
-    try:
-        loaded_config_data = load_and_log_configs()
-        global anthropic_api_key
-        anthropic_api_key = api_key
-        # API key validation
-        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 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"
-
-        logging.debug(f"Anthropic: Using API Key: {api_key[:5]}...{api_key[-5:]}")
-
-        if system_prompt is not None:
-            logging.debug("Anthropic: Using provided system prompt")
-            pass
-        else:
-            system_prompt = "You are a helpful assistant"
-
-        logging.debug(f"AnthropicAI: Loaded data: {input_data}")
-        logging.debug(f"AnthropicAI: Type of data: {type(input_data)}")
-
-        anthropic_model = loaded_config_data['models']['anthropic']
-
-        headers = {
-            'x-api-key': anthropic_api_key,
-            'anthropic-version': '2023-06-01',
-            'Content-Type': 'application/json'
-        }
-
-        anthropic_user_prompt = custom_prompt_arg
-        logging.debug(f"Anthropic: User Prompt is {anthropic_user_prompt}")
-        user_message = {
-            "role": "user",
-            "content": f"{input_data} \n\n\n\n{anthropic_user_prompt}"
-        }
-
-        data = {
-            "model": model,
-            "max_tokens": 4096,  # max _possible_ tokens to return
-            "messages": [user_message],
-            "stop_sequences": ["\n\nHuman:"],
-            "temperature": 0.1,
-            "top_k": 0,
-            "top_p": 1.0,
-            "metadata": {
-                "user_id": "example_user_id",
-            },
-            "stream": False,
-            "system": f"{system_prompt}"
-        }
-
-        for attempt in range(max_retries):
-            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")
-                    response_data = response.json()
-                    try:
-                        chat_response = response_data['content'][0]['text'].strip()
-                        logging.debug("anthropic: Chat request successful")
-                        print("Chat request processed successfully.")
-                        return chat_response
-                    except (IndexError, KeyError) as e:
-                        logging.debug("anthropic: Unexpected data in response")
-                        print("Unexpected response format from Anthropic API:", response.text)
-                        return None
-                elif response.status_code == 500:  # Handle internal server error specifically
-                    logging.debug("anthropic: Internal server error")
-                    print("Internal server error from API. Retrying may be necessary.")
-                    time.sleep(retry_delay)
-                else:
-                    logging.debug(
-                        f"anthropic: Failed to process chat request, status code {response.status_code}: {response.text}")
-                    print(f"Failed to process chat request, status code {response.status_code}: {response.text}")
-                    return None
-
-            except RequestException as e:
-                logging.error(f"anthropic: Network error during attempt {attempt + 1}/{max_retries}: {str(e)}")
-                if attempt < max_retries - 1:
-                    time.sleep(retry_delay)
-                else:
-                    return f"anthropic: Network error: {str(e)}"
-    except Exception as e:
-        logging.error(f"anthropic: Error in processing: {str(e)}")
-        return f"anthropic: Error occurred while processing summary with Anthropic: {str(e)}"
-
-
-# Summarize with Cohere
-def chat_with_cohere(api_key, input_data, model, custom_prompt_arg, system_prompt=None):
-    loaded_config_data = load_and_log_configs()
-    if api_key is not None:
-        logging.debug(f"Cohere Chat: API Key from parameter: {api_key[:3]}...{api_key[-3:]}")
-    logging.debug(f"Cohere Chat: Cohere API Key from config: {loaded_config_data['api_keys']['cohere']}")
-    try:
-        # API key validation
-        if api_key is None:
-            logging.info("Cohere Chat: API key not provided as parameter")
-            logging.info("Cohere Chat: Attempting to use API key from config file")
-            cohere_api_key = loaded_config_data.get('api_keys', {}).get('cohere')
-            if not cohere_api_key:
-                logging.error("Cohere Chat: API key not found or is empty")
-                return "Cohere Chat: API Key Not Provided/Found in Config file or is empty"
-
-        logging.debug(f"Cohere Chat: Using API Key: {cohere_api_key[:3]}...{cohere_api_key[-3:]}")
-
-        logging.debug(f"Cohere Chat: Loaded data: {input_data}")
-        logging.debug(f"Cohere Chat: Type of data: {type(input_data)}")
-
-        # Ensure model is set
-        if not model:
-            model = loaded_config_data['models']['cohere']
-        logging.debug(f"Cohere Chat: Using model: {model}")
-
-        headers = {
-            'accept': 'application/json',
-            'content-type': 'application/json',
-            'Authorization': f'Bearer {cohere_api_key}'
-        }
-
-        # Ensure system_prompt is set
-        if not system_prompt:
-            system_prompt = "You are a helpful assistant"
-        logging.debug(f"Cohere Chat: System Prompt being sent is: '{system_prompt}'")
-
-        cohere_prompt = input_data
-        if custom_prompt_arg:
-            cohere_prompt += f"\n\n{custom_prompt_arg}"
-        logging.debug(f"Cohere Chat: User Prompt being sent is: '{cohere_prompt}'")
-
-        data = {
-            "chat_history": [
-                {"role": "SYSTEM", "message": system_prompt},
-            ],
-            "message": cohere_prompt,
-            "model": model,
-            "connectors": [{"id": "web-search"}]
-        }
-        logging.debug(f"Cohere Chat: Request data: {json.dumps(data, indent=2)}")
-
-        logging.debug("cohere chat: Submitting request to API endpoint")
-        print("cohere chat: Submitting request to API endpoint")
-
-        try:
-            response = requests.post('https://api.cohere.ai/v1/chat', headers=headers, json=data)
-            logging.debug(f"Cohere Chat: Raw API response: {response.text}")
-        except requests.RequestException as e:
-            logging.error(f"Cohere Chat: Error making API request: {str(e)}")
-            return f"Cohere Chat: Error making API request: {str(e)}"
-
-        if response.status_code == 200:
-            try:
-                response_data = response.json()
-            except json.JSONDecodeError:
-                logging.error("Cohere Chat: Failed to decode JSON response")
-                return "Cohere Chat: Failed to decode JSON response"
-
-            if response_data is None:
-                logging.error("Cohere Chat: No response data received.")
-                return "Cohere Chat: No response data received."
-
-            logging.debug(f"cohere chat: Full API response data: {json.dumps(response_data, indent=2)}")
-
-            if 'text' in response_data:
-                chat_response = response_data['text'].strip()
-                logging.debug("Cohere Chat: Chat request successful")
-                print("Cohere Chat request processed successfully.")
-                return chat_response
-            else:
-                logging.error("Cohere Chat: Expected 'text' key not found in API response.")
-                return "Cohere Chat: Expected data not found in API response."
-        else:
-            logging.error(f"Cohere Chat: API request failed with status code {response.status_code}: {response.text}")
-            print(f"Cohere Chat: Failed to process chat response, status code {response.status_code}: {response.text}")
-            return f"Cohere Chat: API request failed: {response.text}"
-
-    except Exception as e:
-        logging.error(f"Cohere Chat: Error in processing: {str(e)}", exc_info=True)
-        return f"Cohere Chat: Error occurred while processing chat request with Cohere: {str(e)}"
-
-
-# https://console.groq.com/docs/quickstart
-def chat_with_groq(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
-    logging.debug("Groq: Summarization process starting...")
-    try:
-        logging.debug("Groq: Loading and validating configurations")
-        loaded_config_data = load_and_log_configs()
-        if loaded_config_data is None:
-            logging.error("Failed to load configuration data")
-            groq_api_key = None
-        else:
-            # Prioritize the API key passed as a parameter
-            if api_key and api_key.strip():
-                groq_api_key = api_key
-                logging.info("Groq: Using API key provided as parameter")
-            else:
-                # If no parameter is provided, use the key from the config
-                groq_api_key = loaded_config_data['api_keys'].get('groq')
-                if groq_api_key:
-                    logging.info("Groq: Using API key from config file")
-                else:
-                    logging.warning("Groq: No API key found in config file")
-
-        # Final check to ensure we have a valid API key
-        if not groq_api_key or not groq_api_key.strip():
-            logging.error("Anthropic: No valid API key available")
-            # You might want to raise an exception here or handle this case as appropriate for your application
-            # For example: raise ValueError("No valid Anthropic API key available")
-
-        logging.debug(f"Groq: Using API Key: {groq_api_key[:5]}...{groq_api_key[-5:]}")
-
-        # Transcript data handling & Validation
-        if isinstance(input_data, str) and os.path.isfile(input_data):
-            logging.debug("Groq: Loading json data for summarization")
-            with open(input_data, 'r') as file:
-                data = json.load(file)
-        else:
-            logging.debug("Groq: Using provided string data for summarization")
-            data = input_data
-
-        # DEBUG - Debug logging to identify sent data
-        logging.debug(f"Groq: Loaded data: {data[:500]}...(snipped to first 500 chars)")
-        logging.debug(f"Groq: 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("Groq: 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("Groq: Invalid input data format")
-
-        # Set the model to be used
-        groq_model = loaded_config_data['models']['groq']
-
-        if temp is None:
-            temp = 0.2
-        temp = float(temp)
-        if system_message is None:
-            system_message = "You are a helpful AI assistant who does whatever the user requests."
-
-        headers = {
-            'Authorization': f'Bearer {groq_api_key}',
-            'Content-Type': 'application/json'
-        }
-
-        groq_prompt = f"{text} \n\n\n\n{custom_prompt_arg}"
-        logging.debug("groq: Prompt being sent is {groq_prompt}")
-
-        data = {
-            "messages": [
-                {
-                    "role": "system",
-                    "content": system_message,
-                },
-                {
-                    "role": "user",
-                    "content": groq_prompt,
-                }
-            ],
-            "model": groq_model,
-            "temperature": temp
-        }
-
-        logging.debug("groq: Submitting request to API endpoint")
-        print("groq: Submitting request to API endpoint")
-        response = requests.post('https://api.groq.com/openai/v1/chat/completions', headers=headers, json=data)
-
-        response_data = response.json()
-        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")
-                print("Groq: Chat request successful.")
-                return summary
-            else:
-                logging.error("Groq(chat): Expected data not found in API response.")
-                return "Groq(chat): Expected data not found in API response."
-        else:
-            logging.error(f"groq: API request failed with status code {response.status_code}: {response.text}")
-            return f"groq: API request failed: {response.text}"
-
-    except Exception as e:
-        logging.error("groq: Error in processing: %s", str(e))
-        return f"groq: Error occurred while processing summary with groq: {str(e)}"
-
-
-def chat_with_openrouter(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
-    import requests
-    import json
-    global openrouter_model, openrouter_api_key
-    try:
-        logging.debug("OpenRouter: Loading and validating configurations")
-        loaded_config_data = load_and_log_configs()
-        if loaded_config_data is None:
-            logging.error("Failed to load configuration data")
-            openrouter_api_key = None
-        else:
-            # Prioritize the API key passed as a parameter
-            if api_key and api_key.strip():
-                openrouter_api_key = api_key
-                logging.info("OpenRouter: Using API key provided as parameter")
-            else:
-                # If no parameter is provided, use the key from the config
-                openrouter_api_key = loaded_config_data['api_keys'].get('openrouter')
-                if openrouter_api_key:
-                    logging.info("OpenRouter: Using API key from config file")
-                else:
-                    logging.warning("OpenRouter: No API key found in config file")
-
-        # Model Selection validation
-        logging.debug("OpenRouter: Validating model selection")
-        loaded_config_data = load_and_log_configs()
-        openrouter_model = loaded_config_data['models']['openrouter']
-        logging.debug(f"OpenRouter: Using model from config file: {openrouter_model}")
-
-        # Final check to ensure we have a valid API key
-        if not openrouter_api_key or not openrouter_api_key.strip():
-            logging.error("OpenRouter: No valid API key available")
-            raise ValueError("No valid Anthropic API key available")
-    except Exception as e:
-        logging.error("OpenRouter: Error in processing: %s", str(e))
-        return f"OpenRouter: Error occurred while processing config file with OpenRouter: {str(e)}"
-
-    logging.debug(f"OpenRouter: Using API Key: {openrouter_api_key[:5]}...{openrouter_api_key[-5:]}")
-
-    logging.debug(f"OpenRouter: Using Model: {openrouter_model}")
-
-    if isinstance(input_data, str) and os.path.isfile(input_data):
-        logging.debug("OpenRouter: Loading json data for summarization")
-        with open(input_data, 'r') as file:
-            data = json.load(file)
-    else:
-        logging.debug("OpenRouter: Using provided string data for summarization")
-        data = input_data
-
-    # DEBUG - Debug logging to identify sent data
-    logging.debug(f"OpenRouter: Loaded data: {data[:500]}...(snipped to first 500 chars)")
-    logging.debug(f"OpenRouter: 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("OpenRouter: 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("OpenRouter: Invalid input data format")
-
-    openrouter_prompt = f"{input_data} \n\n\n\n{custom_prompt_arg}"
-    logging.debug(f"openrouter: User Prompt being sent is {openrouter_prompt}")
-
-    if temp is None:
-        temp = 0.1
-    temp = float(temp)
-    if system_message is None:
-        system_message = "You are a helpful AI assistant who does whatever the user requests."
-
-    try:
-        logging.debug("OpenRouter: Submitting request to API endpoint")
-        print("OpenRouter: Submitting request to API endpoint")
-        response = requests.post(
-            url="https://openrouter.ai/api/v1/chat/completions",
-            headers={
-                "Authorization": f"Bearer {openrouter_api_key}",
-            },
-            data=json.dumps({
-                "model": openrouter_model,
-                "messages": [
-                    {"role": "system", "content": system_message},
-                    {"role": "user", "content": openrouter_prompt}
-                ],
-                "temperature": temp
-            })
-        )
-
-        response_data = response.json()
-        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:
-                summary = response_data['choices'][0]['message']['content'].strip()
-                logging.debug("openrouter: Chat request successful")
-                print("openrouter: Chat request successful.")
-                return summary
-            else:
-                logging.error("openrouter: Expected data not found in API response.")
-                return "openrouter: Expected data not found in API response."
-        else:
-            logging.error(f"openrouter:  API request failed with status code {response.status_code}: {response.text}")
-            return f"openrouter: API request failed: {response.text}"
-    except Exception as e:
-        logging.error("openrouter: Error in processing: %s", str(e))
-        return f"openrouter: Error occurred while processing chat request with openrouter: {str(e)}"
-
-
-# FIXME: This function is not yet implemented properly
-def chat_with_huggingface(api_key, input_data, custom_prompt_arg, system_prompt=None, temp=None):
-    loaded_config_data = load_and_log_configs()
-    logging.debug(f"huggingface Chat: Chat request process starting...")
-    try:
-        huggingface_api_key = global_huggingface_api_key
-        
-        headers = {
-            "Authorization": f"Bearer {huggingface_api_key}"
-        }
-
-        # Setup model
-        huggingface_model = loaded_config_data['models']['huggingface']
-
-        API_URL = f"https://api-inference.huggingface.co/models/{huggingface_model}/v1/chat/completions"
-        if temp is None:
-            temp = 1.0
-        temp = float(temp)
-        huggingface_prompt = f"{custom_prompt_arg}\n\n\n{input_data}"
-        logging.debug(f"HuggingFace chat: Prompt being sent is {huggingface_prompt}")
-        data = {
-            "model": f"{huggingface_model}",
-            "messages": [{"role": "user", "content": f"{huggingface_prompt}"}],
-            "max_tokens": 4096,
-            "stream": False,
-            "temperature": temp
-        }
-
-        logging.debug("HuggingFace Chat: Submitting request...")
-        response = requests.post(API_URL, headers=headers, json=data)
-        logging.debug(f"Full API response data: {response.text}")
-
-        if response.status_code == 200:
-            response_json = response.json()
-            if "choices" in response_json and len(response_json["choices"]) > 0:
-                generated_text = response_json["choices"][0]["message"]["content"]
-                logging.debug("HuggingFace Chat: Chat request successful")
-                print("HuggingFace Chat: Chat request successful.")
-                return generated_text.strip()
-            else:
-                logging.error("HuggingFace Chat: No generated text in the response")
-                return "HuggingFace Chat: No generated text in the response"
-        else:
-            logging.error(
-                f"HuggingFace Chat: Chat request failed with status code {response.status_code}: {response.text}")
-            return f"HuggingFace Chat: Failed to process chat request, status code {response.status_code}: {response.text}"
-    except Exception as e:
-        logging.error(f"HuggingFace Chat: Error in processing: {str(e)}")
-        print(f"HuggingFace Chat: Error occurred while processing chat request with huggingface: {str(e)}")
-        return None
-
-
-def chat_with_deepseek(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
-    logging.debug("DeepSeek: Summarization process starting...")
-    try:
-        logging.debug("DeepSeek: Loading and validating configurations")
-        loaded_config_data = load_and_log_configs()
-        if loaded_config_data is None:
-            logging.error("Failed to load configuration data")
-            deepseek_api_key = None
-        else:
-            # Prioritize the API key passed as a parameter
-            if api_key and api_key.strip():
-                deepseek_api_key = api_key
-                logging.info("DeepSeek: Using API key provided as parameter")
-            else:
-                # If no parameter is provided, use the key from the config
-                deepseek_api_key = loaded_config_data['api_keys'].get('deepseek')
-                if deepseek_api_key:
-                    logging.info("DeepSeek: Using API key from config file")
-                else:
-                    logging.warning("DeepSeek: No API key found in config file")
-
-        # Final check to ensure we have a valid API key
-        if not deepseek_api_key or not deepseek_api_key.strip():
-            logging.error("DeepSeek: No valid API key available")
-            # You might want to raise an exception here or handle this case as appropriate for your application
-            # For example: raise ValueError("No valid deepseek API key available")
-
-
-        logging.debug(f"DeepSeek: Using API Key: {deepseek_api_key[:5]}...{deepseek_api_key[-5:]}")
-
-        # Input data handling
-        if isinstance(input_data, str) and os.path.isfile(input_data):
-            logging.debug("DeepSeek: Loading json data for summarization")
-            with open(input_data, 'r') as file:
-                data = json.load(file)
-        else:
-            logging.debug("DeepSeek: Using provided string data for summarization")
-            data = input_data
-
-        # DEBUG - Debug logging to identify sent data
-        logging.debug(f"DeepSeek: Loaded data: {data[:500]}...(snipped to first 500 chars)")
-        logging.debug(f"DeepSeek: 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("DeepSeek: Summary already exists in the loaded data")
-            return data['summary']
-
-        # Text extraction
-        if isinstance(data, list):
-            segments = data
-            text = extract_text_from_segments(segments)
-        elif isinstance(data, str):
-            text = data
-        else:
-            raise ValueError("DeepSeek: Invalid input data format")
-
-        deepseek_model = loaded_config_data['models']['deepseek'] or "deepseek-chat"
-
-        if temp is None:
-            temp = 0.1
-        temp = float(temp)
-        if system_message is None:
-            system_message = "You are a helpful AI assistant who does whatever the user requests."
-
-        headers = {
-            'Authorization': f'Bearer {api_key}',
-            'Content-Type': 'application/json'
-        }
-
-        logging.debug(
-            f"Deepseek API Key: {api_key[:5]}...{api_key[-5:] if api_key else None}")
-        logging.debug("DeepSeek: Preparing data + prompt for submittal")
-        deepseek_prompt = f"{text} \n\n\n\n{custom_prompt_arg}"
-        data = {
-            "model": deepseek_model,
-            "messages": [
-                {"role": "system", "content": system_message},
-                {"role": "user", "content": deepseek_prompt}
-            ],
-            "stream": False,
-            "temperature": temp
-        }
-
-        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")
-                return summary
-            else:
-                logging.warning("DeepSeek: Chat response not found in the response data")
-                return "DeepSeek: Chat response not available"
-        else:
-            logging.error(f"DeepSeek: Chat request failed with status code {response.status_code}")
-            logging.error(f"DeepSeek: Error response: {response.text}")
-            return f"DeepSeek: Failed to chat request summary. Status code: {response.status_code}"
-    except Exception as e:
-        logging.error(f"DeepSeek: Error in processing: {str(e)}", exc_info=True)
-        return f"DeepSeek: Error occurred while processing chat request: {str(e)}"
-
-
-def chat_with_mistral(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
-    logging.debug("Mistral: Chat request made")
-    try:
-        logging.debug("Mistral: Loading and validating configurations")
-        loaded_config_data = load_and_log_configs()
-        if loaded_config_data is None:
-            logging.error("Failed to load configuration data")
-            mistral_api_key = None
-        else:
-            # Prioritize the API key passed as a parameter
-            if api_key and api_key.strip():
-                mistral_api_key = api_key
-                logging.info("Mistral: Using API key provided as parameter")
-            else:
-                # If no parameter is provided, use the key from the config
-                mistral_api_key = loaded_config_data['api_keys'].get('mistral')
-                if mistral_api_key:
-                    logging.info("Mistral: Using API key from config file")
-                else:
-                    logging.warning("Mistral: No API key found in config file")
-
-        # Final check to ensure we have a valid API key
-        if not mistral_api_key or not mistral_api_key.strip():
-            logging.error("Mistral: No valid API key available")
-            return "Mistral: No valid API key available"
-
-        logging.debug(f"Mistral: Using API Key: {mistral_api_key[:5]}...{mistral_api_key[-5:]}")
-
-        logging.debug("Mistral: Using provided string data")
-        data = input_data
-
-        # Text extraction
-        if isinstance(input_data, list):
-            text = extract_text_from_segments(input_data)
-        elif isinstance(input_data, str):
-            text = input_data
-        else:
-            raise ValueError("Mistral: Invalid input data format")
-
-        mistral_model = loaded_config_data['models'].get('mistral', "mistral-large-latest")
-
-        temp = float(temp) if temp is not None else 0.2
-        if system_message is None:
-            system_message = "You are a helpful AI assistant who does whatever the user requests."
-
-        headers = {
-            'Authorization': f'Bearer {mistral_api_key}',
-            'Content-Type': 'application/json'
-        }
-
-        logging.debug(
-            f"Deepseek API Key: {mistral_api_key[:5]}...{mistral_api_key[-5:] if mistral_api_key else None}")
-        logging.debug("Mistral: Preparing data + prompt for submittal")
-        mistral_prompt = f"{custom_prompt_arg}\n\n\n\n{text} "
-        data = {
-            "model": mistral_model,
-            "messages": [
-                {"role": "system",
-                 "content": system_message},
-                {"role": "user",
-                "content": mistral_prompt}
-            ],
-            "temperature": temp,
-            "top_p": 1,
-            "max_tokens": 4096,
-            "stream": False,
-            "safe_prompt": False
-        }
-
-        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")
-                return summary
-            else:
-                logging.warning("Mistral: Chat response not found in the response data")
-                return "Mistral: Chat response not available"
-        else:
-            logging.error(f"Mistral: Chat request failed with status code {response.status_code}")
-            logging.error(f"Mistral: Error response: {response.text}")
-            return f"Mistral: Failed to process summary. Status code: {response.status_code}. Error: {response.text}"
-    except Exception as e:
-        logging.error(f"Mistral: Error in processing: {str(e)}", exc_info=True)
-        return f"Mistral: Error occurred while processing Chat: {str(e)}"
-
-
-
-# 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
-
-
-
-#
-#
+# Summarization_General_Lib.py
+#########################################
+# General Summarization Library
+# This library is used to perform summarization.
+#
+####
+####################
+# Function List
+#
+# 1. extract_text_from_segments(segments: List[Dict]) -> str
+# 2. chat_with_openai(api_key, file_path, custom_prompt_arg)
+# 3. chat_with_anthropic(api_key, file_path, model, custom_prompt_arg, max_retries=3, retry_delay=5)
+# 4. chat_with_cohere(api_key, file_path, model, custom_prompt_arg)
+# 5. chat_with_groq(api_key, input_data, custom_prompt_arg, system_prompt=None):
+# 6. chat_with_openrouter(api_key, input_data, custom_prompt_arg, system_prompt=None)
+# 7. chat_with_huggingface(api_key, input_data, custom_prompt_arg, system_prompt=None)
+# 8. chat_with_deepseek(api_key, input_data, custom_prompt_arg, system_prompt=None)
+# 9. 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)
+#
+#
+####################
+#
+# Import necessary libraries
+import json
+import logging
+import os
+import time
+from typing import List
+
+import requests
+#
+# Import 3rd-Party Libraries
+#
+# Import Local libraries
+from App_Function_Libraries.Utils.Utils import load_and_log_configs
+#
+#######################################################################################################################
+# Function Definitions
+#
+
+#FIXME: Update to include full arguments
+
+def extract_text_from_segments(segments):
+    logging.debug(f"Segments received: {segments}")
+    logging.debug(f"Type of segments: {type(segments)}")
+
+    text = ""
+
+    if isinstance(segments, list):
+        for segment in segments:
+            logging.debug(f"Current segment: {segment}")
+            logging.debug(f"Type of segment: {type(segment)}")
+            if 'Text' in segment:
+                text += segment['Text'] + " "
+            else:
+                logging.warning(f"Skipping segment due to missing 'Text' key: {segment}")
+    else:
+        logging.warning(f"Unexpected type of 'segments': {type(segments)}")
+
+    return text.strip()
+
+
+
+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 not openai_api_key:
+            logging.info("OpenAI: API key not provided as parameter")
+            logging.info("OpenAI: Attempting to use API key from config file")
+            openai_api_key = loaded_config_data['api_keys']['openai']
+
+        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: {openai_api_key[:5]}...{openai_api_key[-5:]}")
+
+        # Input data handling
+        logging.debug(f"OpenAI: Raw input data type: {type(input_data)}")
+        logging.debug(f"OpenAI: 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("OpenAI: Parsing provided JSON string data for summarization")
+                try:
+                    data = json.loads(input_data)
+                except json.JSONDecodeError as e:
+                    logging.error(f"OpenAI: Error parsing JSON string: {str(e)}")
+                    return f"OpenAI: Error parsing JSON input: {str(e)}"
+            elif os.path.isfile(input_data):
+                logging.debug("OpenAI: Loading JSON data from file for summarization")
+                with open(input_data, 'r') as file:
+                    data = json.load(file)
+            else:
+                logging.debug("OpenAI: Using provided string data for summarization")
+                data = input_data
+        else:
+            data = input_data
+
+        logging.debug(f"OpenAI: Processed data type: {type(data)}")
+        logging.debug(f"OpenAI: Processed data (first 500 chars): {str(data)[:500]}...")
+
+        # Text extraction
+        if isinstance(data, dict):
+            if 'summary' in data:
+                logging.debug("OpenAI: 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"OpenAI: Invalid input data format: {type(data)}")
+
+        logging.debug(f"OpenAI: Extracted text (first 500 chars): {text[:500]}...")
+        logging.debug(f"OpenAI: Custom prompt: {custom_prompt_arg}")
+
+        openai_model = loaded_config_data['models']['openai'] or "gpt-4o"
+        logging.debug(f"OpenAI: Using model: {openai_model}")
+
+        headers = {
+            'Authorization': f'Bearer {openai_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        logging.debug(
+            f"OpenAI API Key: {openai_api_key[:5]}...{openai_api_key[-5:] if openai_api_key else None}")
+        logging.debug("openai: 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
+        }
+
+        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")
+                return "openai: Chat not available"
+        else:
+            logging.error(f"OpenAI: Chat request failed with status code {response.status_code}")
+            logging.error(f"OpenAI: 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"OpenAI: Error decoding JSON: {str(e)}", exc_info=True)
+        return f"OpenAI: Error decoding JSON input: {str(e)}"
+    except requests.RequestException as e:
+        logging.error(f"OpenAI: Error making API request: {str(e)}", exc_info=True)
+        return f"OpenAI: Error making API request: {str(e)}"
+    except Exception as e:
+        logging.error(f"OpenAI: Unexpected error: {str(e)}", exc_info=True)
+        return f"OpenAI: Unexpected error occurred: {str(e)}"
+
+
+def chat_with_anthropic(api_key, input_data, model, custom_prompt_arg, max_retries=3, retry_delay=5, system_prompt=None, temp=None):
+    try:
+        loaded_config_data = load_and_log_configs()
+
+        # Check if config was loaded successfully
+        if loaded_config_data is None:
+            logging.error("Anthropic: Failed to load configuration data.")
+            return "Anthropic: Failed to load configuration data."
+
+        # Initialize the API key
+        anthropic_api_key = api_key
+
+        # API key validation
+        if not api_key:
+            logging.info("Anthropic: API key not provided as parameter")
+            logging.info("Anthropic: Attempting to use API key from config file")
+            # Ensure 'api_keys' and 'anthropic' keys exist
+            try:
+                anthropic_api_key = loaded_config_data['api_keys']['anthropic']
+                logging.debug(f"Anthropic: Loaded API Key from config: {anthropic_api_key[:5]}...{anthropic_api_key[-5:]}")
+            except (KeyError, TypeError) as e:
+                logging.error(f"Anthropic: Error accessing API key from config: {str(e)}")
+                return "Anthropic: API Key Not Provided/Found in Config file or is empty"
+
+        if not anthropic_api_key or anthropic_api_key == "":
+            logging.error("Anthropic: API key not found or is empty")
+            return "Anthropic: API Key Not Provided/Found in Config file or is empty"
+
+        if anthropic_api_key:
+            logging.debug(f"Anthropic: Using API Key: {anthropic_api_key[:5]}...{anthropic_api_key[-5:]}")
+        else:
+            logging.debug(f"Anthropic: Using API Key: {api_key[:5]}...{api_key[-5:]}")
+
+        if system_prompt is not None:
+            logging.debug("Anthropic: Using provided system prompt")
+            pass
+        else:
+            system_prompt = "You are a helpful assistant"
+            logging.debug("Anthropic: Using default system prompt")
+
+        logging.debug(f"AnthropicAI: Loaded data: {input_data}")
+        logging.debug(f"AnthropicAI: Type of data: {type(input_data)}")
+
+        # Retrieve the model from config if not provided
+        if not model:
+            try:
+                anthropic_model = loaded_config_data['models']['anthropic']
+                logging.debug(f"Anthropic: Loaded model from config: {anthropic_model}")
+            except (KeyError, TypeError) as e:
+                logging.error(f"Anthropic: Error accessing model from config: {str(e)}")
+                return "Anthropic: Model configuration not found."
+        else:
+            anthropic_model = model
+            logging.debug(f"Anthropic: Using provided model: {anthropic_model}")
+
+        if temp is None:
+            temp = 1.0
+            logging.debug(f"Anthropic: Using default temperature: {temp}")
+
+        headers = {
+            'x-api-key': anthropic_api_key,
+            'anthropic-version': '2023-06-01',
+            'Content-Type': 'application/json'
+        }
+
+        anthropic_user_prompt = custom_prompt_arg if custom_prompt_arg else ""
+        logging.debug(f"Anthropic: User Prompt is '{anthropic_user_prompt}'")
+        user_message = {
+            "role": "user",
+            "content": f"{input_data} \n\n\n\n{anthropic_user_prompt}"
+        }
+
+        data = {
+            "model": anthropic_model,
+            "max_tokens": 4096,  # max possible tokens to return
+            "messages": [user_message],
+            "stop_sequences": ["\n\nHuman:"],
+            "temperature": temp,
+            "top_k": 0,
+            "top_p": 1.0,
+            "metadata": {
+                "user_id": "example_user_id",
+            },
+            "stream": False,
+            "system": system_prompt
+        }
+
+        for attempt in range(max_retries):
+            try:
+                logging.debug("Anthropic: Posting request to API")
+                response = requests.post('https://api.anthropic.com/v1/messages', headers=headers, json=data)
+                logging.debug(f"Anthropic: Full API response data: {response}")
+
+                # Check if the status code indicates success
+                if response.status_code == 200:
+                    logging.debug("Anthropic: Post submittal successful")
+                    response_data = response.json()
+
+                    # Corrected path to access the assistant's reply
+                    if 'content' in response_data and isinstance(response_data['content'], list) and len(response_data['content']) > 0:
+                        chat_response = response_data['content'][0]['text'].strip()
+                        logging.debug("Anthropic: Chat request successful")
+                        print("Chat request processed successfully.")
+                        return chat_response
+                    else:
+                        logging.error("Anthropic: Unexpected data structure in response.")
+                        print("Unexpected response format from Anthropic API:", response.text)
+                        return "Anthropic: Unexpected response format from API."
+                elif response.status_code == 500:  # Handle internal server error specifically
+                    logging.debug("Anthropic: Internal server error")
+                    print("Internal server error from API. Retrying may be necessary.")
+                    time.sleep(retry_delay)
+                else:
+                    logging.debug(
+                        f"Anthropic: Failed to process chat request, status code {response.status_code}: {response.text}")
+                    print(f"Failed to process chat request, status code {response.status_code}: {response.text}")
+                    return f"Anthropic: Failed to process chat request, status code {response.status_code}: {response.text}"
+
+            except requests.RequestException as e:
+                logging.error(f"Anthropic: Network error during attempt {attempt + 1}/{max_retries}: {str(e)}")
+                if attempt < max_retries - 1:
+                    logging.debug(f"Anthropic: Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                else:
+                    return f"Anthropic: Network error: {str(e)}"
+
+    except Exception as e:
+        logging.error(f"Anthropic: Error in processing: {str(e)}")
+        return f"Anthropic: Error occurred while processing summary with Anthropic: {str(e)}"
+
+
+# Summarize with Cohere
+def chat_with_cohere(api_key, input_data, model=None, custom_prompt_arg=None, system_prompt=None, temp=None):
+    loaded_config_data = load_and_log_configs()
+    cohere_api_key = None
+
+    try:
+        # API key validation
+        if api_key:
+            logging.info(f"Cohere Chat: API Key from parameter: {api_key[:3]}...{api_key[-3:]}")
+            cohere_api_key = api_key
+        else:
+            logging.info("Cohere Chat: API key not provided as parameter")
+            logging.info("Cohere Chat: Attempting to use API key from config file")
+            logging.debug(f"Cohere Chat: Cohere API Key from config: {loaded_config_data['api_keys']['cohere']}")
+            cohere_api_key = loaded_config_data['api_keys']['cohere']
+            if cohere_api_key:
+                logging.debug(f"Cohere Chat: Cohere API Key from config: {cohere_api_key[:3]}...{cohere_api_key[-3:]}")
+            else:
+                logging.error("Cohere Chat: API key not found or is empty")
+                return "Cohere Chat: API Key Not Provided/Found in Config file or is empty"
+
+        logging.debug(f"Cohere Chat: Loaded data: {input_data}")
+        logging.debug(f"Cohere Chat: Type of data: {type(input_data)}")
+
+        # Ensure model is set
+        if not model:
+            model = loaded_config_data['models']['cohere']
+        logging.debug(f"Cohere Chat: Using model: {model}")
+
+        if temp is None:
+            temp = 0.3
+        else:
+            try:
+                temp = float(temp)
+            except ValueError:
+                logging.warning(f"Cohere Chat: Invalid temperature value '{temp}', defaulting to 0.3")
+                temp = 0.3
+
+        headers = {
+            'accept': 'application/json',
+            'content-type': 'application/json',
+            'Authorization': f'Bearer {cohere_api_key}'
+        }
+
+        # Ensure system_prompt is set
+        if not system_prompt:
+            system_prompt = "You are a helpful assistant"
+        logging.debug(f"Cohere Chat: System Prompt being sent is: '{system_prompt}'")
+
+        cohere_prompt = input_data
+        if custom_prompt_arg:
+            cohere_prompt += f"\n\n{custom_prompt_arg}"
+        logging.debug(f"Cohere Chat: User Prompt being sent is: '{cohere_prompt}'")
+
+        data = {
+            "model" : model,
+            "temperature": temp,
+            "messages": [
+                {
+                    "role": "system",
+                    "content":  system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": cohere_prompt,
+                }
+            ],
+        }
+        logging.debug(f"Cohere Chat: Request data: {json.dumps(data, indent=2)}")
+
+        logging.debug("cohere chat: Submitting request to API endpoint")
+        print("cohere chat: Submitting request to API endpoint")
+
+        try:
+            response = requests.post('https://api.cohere.ai/v2/chat', headers=headers, json=data)
+            logging.debug(f"Cohere Chat: Raw API response: {response.text}")
+        except requests.RequestException as e:
+            logging.error(f"Cohere Chat: Error making API request: {str(e)}")
+            return f"Cohere Chat: Error making API request: {str(e)}"
+
+        if response.status_code == 200:
+            try:
+                response_data = response.json()
+            except json.JSONDecodeError:
+                logging.error("Cohere Chat: Failed to decode JSON response")
+                return "Cohere Chat: Failed to decode JSON response"
+
+            if response_data is None:
+                logging.error("Cohere Chat: No response data received.")
+                return "Cohere Chat: No response data received."
+
+            logging.debug(f"cohere chat: Full API response data: {json.dumps(response_data, indent=2)}")
+
+            if 'message' in response_data and 'content' in response_data['message']:
+                content = response_data['message']['content']
+                if isinstance(content, list) and len(content) > 0:
+                    # Extract text from the first content block
+                    text = content[0].get('text', '').strip()
+                    if text:
+                        logging.debug("Cohere Chat: Chat request successful")
+                        print("Cohere Chat request processed successfully.")
+                        return text
+                    else:
+                        logging.error("Cohere Chat: 'text' field is empty in response content.")
+                        return "Cohere Chat: 'text' field is empty in response content."
+                else:
+                    logging.error("Cohere Chat: 'content' field is not a list or is empty.")
+                    return "Cohere Chat: 'content' field is not a list or is empty."
+            else:
+                logging.error("Cohere Chat: 'message' or 'content' field not found in API response.")
+                return "Cohere Chat: 'message' or 'content' field not found in API response."
+
+        elif response.status_code == 401:
+            error_message = "Cohere Chat: Unauthorized - Invalid API key"
+            logging.warning(error_message)
+            print(error_message)
+            return error_message
+
+        else:
+            logging.error(f"Cohere Chat: API request failed with status code {response.status_code}: {response.text}")
+            print(f"Cohere Chat: Failed to process chat response, status code {response.status_code}: {response.text}")
+            return f"Cohere Chat: API request failed: {response.text}"
+
+    except Exception as e:
+        logging.error(f"Cohere Chat: Error in processing: {str(e)}", exc_info=True)
+        return f"Cohere Chat: Error occurred while processing chat request with Cohere: {str(e)}"
+
+
+# https://console.groq.com/docs/quickstart
+def chat_with_groq(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
+    logging.debug("Groq: Summarization process starting...")
+    try:
+        logging.debug("Groq: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            groq_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                groq_api_key = api_key
+                logging.info("Groq: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                groq_api_key = loaded_config_data['api_keys'].get('groq')
+                if groq_api_key:
+                    logging.info("Groq: Using API key from config file")
+                else:
+                    logging.warning("Groq: No API key found in config file")
+
+        # Final check to ensure we have a valid API key
+        if not groq_api_key or not groq_api_key.strip():
+            logging.error("Anthropic: No valid API key available")
+            # You might want to raise an exception here or handle this case as appropriate for your application
+            # For example: raise ValueError("No valid Anthropic API key available")
+
+        logging.debug(f"Groq: Using API Key: {groq_api_key[:5]}...{groq_api_key[-5:]}")
+
+        # Transcript data handling & Validation
+        if isinstance(input_data, str) and os.path.isfile(input_data):
+            logging.debug("Groq: Loading json data for summarization")
+            with open(input_data, 'r') as file:
+                data = json.load(file)
+        else:
+            logging.debug("Groq: Using provided string data for summarization")
+            data = input_data
+
+        # DEBUG - Debug logging to identify sent data
+        logging.debug(f"Groq: Loaded data: {data[:500]}...(snipped to first 500 chars)")
+        logging.debug(f"Groq: 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("Groq: 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("Groq: Invalid input data format")
+
+        # Set the model to be used
+        groq_model = loaded_config_data['models']['groq']
+
+        if temp is None:
+            temp = 0.2
+        temp = float(temp)
+        if system_message is None:
+            system_message = "You are a helpful AI assistant who does whatever the user requests."
+
+        headers = {
+            'Authorization': f'Bearer {groq_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        groq_prompt = f"{text} \n\n\n\n{custom_prompt_arg}"
+        logging.debug("groq: Prompt being sent is {groq_prompt}")
+
+        data = {
+            "messages": [
+                {
+                    "role": "system",
+                    "content": system_message,
+                },
+                {
+                    "role": "user",
+                    "content": groq_prompt,
+                }
+            ],
+            "model": groq_model,
+            "temperature": temp
+        }
+
+        logging.debug("groq: Submitting request to API endpoint")
+        print("groq: Submitting request to API endpoint")
+        response = requests.post('https://api.groq.com/openai/v1/chat/completions', headers=headers, json=data)
+
+        response_data = response.json()
+        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")
+                print("Groq: Chat request successful.")
+                return summary
+            else:
+                logging.error("Groq(chat): Expected data not found in API response.")
+                return "Groq(chat): Expected data not found in API response."
+        else:
+            logging.error(f"groq: API request failed with status code {response.status_code}: {response.text}")
+            return f"groq: API request failed: {response.text}"
+
+    except Exception as e:
+        logging.error("groq: Error in processing: %s", str(e))
+        return f"groq: Error occurred while processing summary with groq: {str(e)}"
+
+
+def chat_with_openrouter(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
+    import requests
+    import json
+    global openrouter_model, openrouter_api_key
+    try:
+        logging.debug("OpenRouter: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            openrouter_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                openrouter_api_key = api_key
+                logging.info("OpenRouter: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                openrouter_api_key = loaded_config_data['api_keys'].get('openrouter')
+                if openrouter_api_key:
+                    logging.info("OpenRouter: Using API key from config file")
+                else:
+                    logging.warning("OpenRouter: No API key found in config file")
+
+        # Model Selection validation
+        logging.debug("OpenRouter: Validating model selection")
+        loaded_config_data = load_and_log_configs()
+        openrouter_model = loaded_config_data['models']['openrouter']
+        logging.debug(f"OpenRouter: Using model from config file: {openrouter_model}")
+
+        # Final check to ensure we have a valid API key
+        if not openrouter_api_key or not openrouter_api_key.strip():
+            logging.error("OpenRouter: No valid API key available")
+            raise ValueError("No valid Anthropic API key available")
+    except Exception as e:
+        logging.error("OpenRouter: Error in processing: %s", str(e))
+        return f"OpenRouter: Error occurred while processing config file with OpenRouter: {str(e)}"
+
+    logging.debug(f"OpenRouter: Using API Key: {openrouter_api_key[:5]}...{openrouter_api_key[-5:]}")
+
+    logging.debug(f"OpenRouter: Using Model: {openrouter_model}")
+
+    if isinstance(input_data, str) and os.path.isfile(input_data):
+        logging.debug("OpenRouter: Loading json data for summarization")
+        with open(input_data, 'r') as file:
+            data = json.load(file)
+    else:
+        logging.debug("OpenRouter: Using provided string data for summarization")
+        data = input_data
+
+    # DEBUG - Debug logging to identify sent data
+    logging.debug(f"OpenRouter: Loaded data: {data[:500]}...(snipped to first 500 chars)")
+    logging.debug(f"OpenRouter: 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("OpenRouter: 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("OpenRouter: Invalid input data format")
+
+    openrouter_prompt = f"{input_data} \n\n\n\n{custom_prompt_arg}"
+    logging.debug(f"openrouter: User Prompt being sent is {openrouter_prompt}")
+
+    if temp is None:
+        temp = 0.1
+    temp = float(temp)
+    if system_message is None:
+        system_message = "You are a helpful AI assistant who does whatever the user requests."
+
+    try:
+        logging.debug("OpenRouter: Submitting request to API endpoint")
+        print("OpenRouter: Submitting request to API endpoint")
+        response = requests.post(
+            url="https://openrouter.ai/api/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {openrouter_api_key}",
+            },
+            data=json.dumps({
+                "model": openrouter_model,
+                "messages": [
+                    {"role": "system", "content": system_message},
+                    {"role": "user", "content": openrouter_prompt}
+                ],
+                "temperature": temp
+            })
+        )
+
+        response_data = response.json()
+        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:
+                summary = response_data['choices'][0]['message']['content'].strip()
+                logging.debug("openrouter: Chat request successful")
+                print("openrouter: Chat request successful.")
+                return summary
+            else:
+                logging.error("openrouter: Expected data not found in API response.")
+                return "openrouter: Expected data not found in API response."
+        else:
+            logging.error(f"openrouter:  API request failed with status code {response.status_code}: {response.text}")
+            return f"openrouter: API request failed: {response.text}"
+    except Exception as e:
+        logging.error("openrouter: Error in processing: %s", str(e))
+        return f"openrouter: Error occurred while processing chat request with openrouter: {str(e)}"
+
+
+# FIXME: This function is not yet implemented properly
+def chat_with_huggingface(api_key, input_data, custom_prompt_arg, system_prompt=None, temp=None):
+    loaded_config_data = load_and_log_configs()
+    logging.debug(f"huggingface Chat: Chat request process starting...")
+    try:
+        # API key validation
+        if not api_key or api_key.strip() == "":
+            logging.info("HuggingFace Chat: API key not provided as parameter")
+            logging.info("HuggingFace Chat: Attempting to use API key from config file")
+
+        huggingface_api_key = loaded_config_data['api_keys'].get('huggingface')
+        logging.debug(f"HuggingFace Chat: API key from config: {huggingface_api_key[:5]}...{huggingface_api_key[-5:]}")
+
+        if huggingface_api_key is None or huggingface_api_key.strip() == "":
+            logging.error("HuggingFace Chat: API key not found or is empty")
+            return "HuggingFace Chat: API Key Not Provided/Found in Config file or is empty"
+        if huggingface_api_key:
+            logging.info("HuggingFace Chat: Using API key from config file")
+        headers = {
+            "Authorization": f"Bearer {huggingface_api_key}"
+        }
+
+        # Setup model
+        huggingface_model = loaded_config_data['models']['huggingface']
+
+        API_URL = f"https://api-inference.huggingface.co/models/{huggingface_model}/v1/chat/completions"
+        if temp is None:
+            temp = 1.0
+        temp = float(temp)
+        huggingface_prompt = f"{custom_prompt_arg}\n\n\n{input_data}"
+        logging.debug(f"HuggingFace chat: Prompt being sent is {huggingface_prompt}")
+        data = {
+            "model": f"{huggingface_model}",
+            "messages": [{"role": "user", "content": f"{huggingface_prompt}"}],
+            "max_tokens": 4096,
+            "stream": False,
+            "temperature": temp
+        }
+
+        logging.debug("HuggingFace Chat: Submitting request...")
+        response = requests.post(API_URL, headers=headers, json=data)
+        logging.debug(f"Full API response data: {response.text}")
+
+        if response.status_code == 200:
+            response_json = response.json()
+            if "choices" in response_json and len(response_json["choices"]) > 0:
+                generated_text = response_json["choices"][0]["message"]["content"]
+                logging.debug("HuggingFace Chat: Chat request successful")
+                print("HuggingFace Chat: Chat request successful.")
+                return generated_text.strip()
+            else:
+                logging.error("HuggingFace Chat: No generated text in the response")
+                return "HuggingFace Chat: No generated text in the response"
+        else:
+            logging.error(
+                f"HuggingFace Chat: Chat request failed with status code {response.status_code}: {response.text}")
+            return f"HuggingFace Chat: Failed to process chat request, status code {response.status_code}: {response.text}"
+    except Exception as e:
+        logging.error(f"HuggingFace Chat: Error in processing: {str(e)}")
+        print(f"HuggingFace Chat: Error occurred while processing chat request with huggingface: {str(e)}")
+        return None
+
+
+def chat_with_deepseek(api_key, input_data, custom_prompt_arg, temp=0.1, system_message="You are a helpful AI assistant who does whatever the user requests.", max_retries=3, retry_delay=5):
+    """
+    Interacts with the DeepSeek API to generate summaries based on input data.
+
+    Parameters:
+        api_key (str): DeepSeek API key. If not provided, the key from the config is used.
+        input_data (str or list): The data to summarize. Can be a string or a list of segments.
+        custom_prompt_arg (str): Custom prompt to append to the input data.
+        temp (float, optional): Temperature setting for the model. Defaults to 0.1.
+        system_message (str, optional): System prompt for the assistant. Defaults to a helpful assistant message.
+        max_retries (int, optional): Maximum number of retries for failed API calls. Defaults to 3.
+        retry_delay (int, optional): Delay between retries in seconds. Defaults to 5.
+
+    Returns:
+        str: The summary generated by DeepSeek or an error message.
+    """
+    logging.debug("DeepSeek: Summarization process starting...")
+    try:
+        logging.debug("DeepSeek: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("DeepSeek: Failed to load configuration data")
+            return "DeepSeek: Failed to load configuration data."
+
+        # Prioritize the API key passed as a parameter
+        if api_key and api_key.strip():
+            deepseek_api_key = api_key.strip()
+            logging.info("DeepSeek: Using API key provided as parameter")
+        else:
+            # If no parameter is provided, use the key from the config
+            deepseek_api_key = loaded_config_data['api_keys'].get('deepseek')
+            if deepseek_api_key and deepseek_api_key.strip():
+                deepseek_api_key = deepseek_api_key.strip()
+                logging.info("DeepSeek: Using API key from config file")
+            else:
+                logging.error("DeepSeek: No valid API key available")
+                return "DeepSeek: API Key Not Provided/Found in Config file or is empty"
+
+        logging.debug("DeepSeek: Using API Key")
+
+        # Input data handling
+        if isinstance(input_data, str) and os.path.isfile(input_data):
+            logging.debug("DeepSeek: Loading JSON data for summarization")
+            with open(input_data, 'r', encoding='utf-8') as file:
+                try:
+                    data = json.load(file)
+                except json.JSONDecodeError as e:
+                    logging.error(f"DeepSeek: JSON decoding failed: {str(e)}")
+                    return f"DeepSeek: Invalid JSON file. Error: {str(e)}"
+        else:
+            logging.debug("DeepSeek: Using provided string data for summarization")
+            data = input_data
+
+        # DEBUG - Debug logging to identify sent data
+        if isinstance(data, str):
+            snipped_data = data[:500] + "..." if len(data) > 500 else data
+            logging.debug(f"DeepSeek: Loaded data (snipped to first 500 chars): {snipped_data}")
+        elif isinstance(data, list):
+            snipped_data = json.dumps(data[:2], indent=2) + "..." if len(data) > 2 else json.dumps(data, indent=2)
+            logging.debug(f"DeepSeek: Loaded data (snipped to first 2 segments): {snipped_data}")
+        else:
+            logging.debug(f"DeepSeek: Loaded data: {data}")
+
+        logging.debug(f"DeepSeek: 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("DeepSeek: Summary already exists in the loaded data")
+            return data['summary']
+
+        # Text extraction
+        if isinstance(data, list):
+            segments = data
+            try:
+                text = extract_text_from_segments(segments)
+                logging.debug("DeepSeek: Extracted text from segments")
+            except Exception as e:
+                logging.error(f"DeepSeek: Error extracting text from segments: {str(e)}")
+                return f"DeepSeek: Error extracting text from segments: {str(e)}"
+        elif isinstance(data, str):
+            text = data
+            logging.debug("DeepSeek: Using string data directly")
+        else:
+            raise ValueError("DeepSeek: Invalid input data format")
+
+        # Retrieve the model from config if not provided
+        deepseek_model = loaded_config_data['models'].get('deepseek', "deepseek-chat")
+        logging.debug(f"DeepSeek: Using model: {deepseek_model}")
+
+        # Ensure temperature is a float within acceptable range
+        try:
+            temp = float(temp)
+            if not (0.0 <= temp <= 1.0):
+                logging.warning("DeepSeek: Temperature out of bounds (0.0 - 1.0). Setting to default 0.1")
+                temp = 0.1
+        except (ValueError, TypeError):
+            logging.warning("DeepSeek: Invalid temperature value. Setting to default 0.1")
+            temp = 0.1
+
+        # Set default system prompt if not provided
+        if system_message is not None:
+            logging.debug("DeepSeek: Using provided system prompt")
+        else:
+            system_message = "You are a helpful AI assistant who does whatever the user requests."
+            logging.debug("DeepSeek: Using default system prompt")
+
+        headers = {
+            'Authorization': f'Bearer {deepseek_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        logging.debug("DeepSeek: Preparing data and prompt for submittal")
+        deepseek_prompt = f"{text}\n\n\n\n{custom_prompt_arg}"
+        payload = {
+            "model": deepseek_model,
+            "messages": [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": deepseek_prompt}
+            ],
+            "stream": False,
+            "temperature": temp
+        }
+
+        logging.debug("DeepSeek: Posting request to API")
+        for attempt in range(1, max_retries + 1):
+            try:
+                response = requests.post('https://api.deepseek.com/chat/completions', headers=headers, json=payload, timeout=30)
+                logging.debug(f"DeepSeek: Full API response: {response.status_code} - {response.text}")
+
+                if response.status_code == 200:
+                    response_data = response.json()
+                    logging.debug(f"DeepSeek: Response JSON: {json.dumps(response_data, indent=2)}")
+
+                    # Adjust parsing based on actual API response structure
+                    if 'choices' in response_data:
+                        if len(response_data['choices']) > 0:
+                            summary = response_data['choices'][0]['message']['content'].strip()
+                            logging.debug("DeepSeek: Chat request successful")
+                            return summary
+                        else:
+                            logging.error("DeepSeek: 'choices' key is empty in response")
+                    else:
+                        logging.error("DeepSeek: 'choices' key missing in response")
+                    return "DeepSeek: Unexpected response format from API."
+                elif 500 <= response.status_code < 600:
+                    logging.error(f"DeepSeek: Server error (status code {response.status_code}). Attempt {attempt} of {max_retries}. Retrying in {retry_delay} seconds...")
+                else:
+                    logging.error(f"DeepSeek: Request failed with status code {response.status_code}. Response: {response.text}")
+                    return f"DeepSeek: Failed to process chat request. Status code: {response.status_code}"
+
+            except requests.Timeout:
+                logging.error(f"DeepSeek: Request timed out. Attempt {attempt} of {max_retries}. Retrying in {retry_delay} seconds...")
+            except requests.RequestException as e:
+                logging.error(f"DeepSeek: Request exception occurred: {str(e)}. Attempt {attempt} of {max_retries}. Retrying in {retry_delay} seconds...")
+
+            if attempt < max_retries:
+                time.sleep(retry_delay)
+            else:
+                logging.error("DeepSeek: Max retries reached. Failed to get a successful response.")
+                return "DeepSeek: Failed to get a successful response from API after multiple attempts."
+
+    except Exception as e:
+        logging.error(f"DeepSeek: Unexpected error in processing: {str(e)}", exc_info=True)
+        return f"DeepSeek: Error occurred while processing chat request: {str(e)}"
+
+
+
+
+def chat_with_mistral(api_key, input_data, custom_prompt_arg, temp=None, system_message=None):
+    logging.debug("Mistral: Chat request made")
+    try:
+        logging.debug("Mistral: Loading and validating configurations")
+        loaded_config_data = load_and_log_configs()
+        if loaded_config_data is None:
+            logging.error("Failed to load configuration data")
+            mistral_api_key = None
+        else:
+            # Prioritize the API key passed as a parameter
+            if api_key and api_key.strip():
+                mistral_api_key = api_key
+                logging.info("Mistral: Using API key provided as parameter")
+            else:
+                # If no parameter is provided, use the key from the config
+                mistral_api_key = loaded_config_data['api_keys'].get('mistral')
+                if mistral_api_key:
+                    logging.info("Mistral: Using API key from config file")
+                else:
+                    logging.warning("Mistral: No API key found in config file")
+
+        # Final check to ensure we have a valid API key
+        if not mistral_api_key or not mistral_api_key.strip():
+            logging.error("Mistral: No valid API key available")
+            return "Mistral: No valid API key available"
+
+        logging.debug(f"Mistral: Using API Key: {mistral_api_key[:5]}...{mistral_api_key[-5:]}")
+
+        logging.debug("Mistral: Using provided string data")
+        data = input_data
+
+        # Text extraction
+        if isinstance(input_data, list):
+            text = extract_text_from_segments(input_data)
+        elif isinstance(input_data, str):
+            text = input_data
+        else:
+            raise ValueError("Mistral: Invalid input data format")
+
+        mistral_model = loaded_config_data['models'].get('mistral', "mistral-large-latest")
+
+        temp = float(temp) if temp is not None else 0.2
+        if system_message is None:
+            system_message = "You are a helpful AI assistant who does whatever the user requests."
+
+        headers = {
+            'Authorization': f'Bearer {mistral_api_key}',
+            'Content-Type': 'application/json'
+        }
+
+        logging.debug(
+            f"Deepseek API Key: {mistral_api_key[:5]}...{mistral_api_key[-5:] if mistral_api_key else None}")
+        logging.debug("Mistral: Preparing data + prompt for submittal")
+        mistral_prompt = f"{custom_prompt_arg}\n\n\n\n{text} "
+        data = {
+            "model": mistral_model,
+            "messages": [
+                {"role": "system",
+                 "content": system_message},
+                {"role": "user",
+                "content": mistral_prompt}
+            ],
+            "temperature": temp,
+            "top_p": 1,
+            "max_tokens": 4096,
+            "stream": False,
+            "safe_prompt": False
+        }
+
+        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")
+                return summary
+            else:
+                logging.warning("Mistral: Chat response not found in the response data")
+                return "Mistral: Chat response not available"
+        else:
+            logging.error(f"Mistral: Chat request failed with status code {response.status_code}")
+            logging.error(f"Mistral: Error response: {response.text}")
+            return f"Mistral: Failed to process summary. Status code: {response.status_code}. Error: {response.text}"
+    except Exception as e:
+        logging.error(f"Mistral: Error in processing: {str(e)}", exc_info=True)
+        return f"Mistral: Error occurred while processing Chat: {str(e)}"
+
+
+
+# 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
+
+
+
+#
+#
 #######################################################################################################################

App_Function_Libraries/LLM_API_Calls_Local.py

@@ -4,6 +4,7 @@
 # This library is used to perform summarization with a 'local' inference engine.
 #
 ####
+import logging
 from typing import Union
 
 ####################
@@ -99,7 +100,8 @@ def chat_with_local_llm(input_data, custom_prompt_arg, temp, system_message=None
         print("Error occurred while processing Chat request with Local LLM:", str(e))
         return "Local LLM: Error occurred while processing Chat response"
 
-def chat_with_llama(input_data, custom_prompt, api_url="http://127.0.0.1:8080/completion", api_key=None, system_prompt=None):
+# FIXME
+def chat_with_llama(input_data, custom_prompt, temp, api_url="http://127.0.0.1:8080/completion", api_key=None, system_prompt=None):
     loaded_config_data = load_and_log_configs()
     try:
         # API key validation
@@ -113,6 +115,15 @@ def chat_with_llama(input_data, custom_prompt, api_url="http://127.0.0.1:8080/co
 
         logging.debug(f"llama.cpp: Using API Key: {api_key[:5]}...{api_key[-5:]}")
 
+        if api_url is None:
+            logging.info("llama.cpp: API URL not provided as parameter")
+            logging.info("llama.cpp: Attempting to use API URL from config file")
+            api_url = loaded_config_data['local_api_ip']['llama']
+
+        if api_url is None or api_url.strip() == "":
+            logging.info("llama.cpp: API URL not found or is empty")
+            return "llama.cpp: API URL not found or is empty"
+
         headers = {
             'accept': 'application/json',
             'content-type': 'application/json',
@@ -132,7 +143,29 @@ def chat_with_llama(input_data, custom_prompt, api_url="http://127.0.0.1:8080/co
 
         data = {
             "prompt": f"{llama_prompt}",
-            "system_prompt": f"{system_prompt}"
+            "system_prompt": f"{system_prompt}",
+            'temperature': temp,
+            #'top_k': '40',
+            #'top_p': '0.95',
+            #'min_p': '0.05',
+            #'n_predict': '-1',
+            #'n_keep': '0',
+            'stream': 'True',
+            #'stop': '["\n"]',
+            #'tfs_z': '1.0',
+            #'repeat_penalty': '1.1',
+            #'repeat_last_n': '64',
+            #'presence_penalty': '0.0',
+            #'frequency_penalty': '0.0',
+            #'mirostat': '0',
+            #'grammar': '0',
+            #'json_schema': '0',
+            #'ignore_eos': 'false',
+            #'logit_bias': [],
+            #'n_probs': '0',
+            #'min_keep': '0',
+            #'samplers': '["top_k", "tfs_z", "typical_p", "top_p", "min_p", "temperature"]',
+
         }
 
         logging.debug("llama: Submitting request to API endpoint")
@@ -400,10 +433,19 @@ def chat_with_aphrodite(input_data, custom_prompt_input, api_key=None, api_IP="h
         return "Error summarizing with Aphrodite."
 
 
-# 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):
+def chat_with_ollama(
+    input_data,
+    custom_prompt,
+    api_url="http://127.0.0.1:11434/v1/chat/completions",
+    api_key=None,
+    temp=None,
+    system_message=None,
+    model=None,
+    max_retries=5,
+    retry_delay=20
+):
     try:
-        logging.debug("ollama: Loading and validating configurations")
+        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")
@@ -421,7 +463,19 @@ def chat_with_ollama(input_data, custom_prompt, api_url="http://127.0.0.1:11434/
                 else:
                     logging.warning("Ollama: No API key found in config file")
 
-        model = loaded_config_data['models']['ollama']
+            # Set model from parameter or config
+            if model is None:
+                model = loaded_config_data['models'].get('ollama')
+                if model is None:
+                    logging.error("Ollama: Model not found in config file")
+                    return "Ollama: Model not found in config file"
+
+            # Set api_url from parameter or config
+            if api_url is None:
+                api_url = loaded_config_data['local_api_ip'].get('ollama')
+                if api_url is None:
+                    logging.error("Ollama: API URL not found in config file")
+                    return "Ollama: API URL not found in config file"
 
         # Load transcript
         logging.debug("Ollama: Loading JSON data")
@@ -454,48 +508,88 @@ def chat_with_ollama(input_data, custom_prompt, api_url="http://127.0.0.1:11434/
             'accept': 'application/json',
             'content-type': 'application/json',
         }
-        if len(ollama_api_key) > 5:
+        if ollama_api_key and 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}")
+        ollama_prompt = f"{custom_prompt}\n\n{text}"
         if system_message is None:
             system_message = "You are a helpful AI assistant."
+        logging.debug(f"Ollama: Prompt being sent is: {ollama_prompt}")
 
-        data = {
+        data_payload = {
             "model": model,
             "messages": [
-                {"role": "system",
-                 "content": system_message
-                 },
-                {"role": "user",
-                 "content": ollama_prompt
-                 }
+                {
+                    "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)
+        for attempt in range(1, max_retries + 1):
+            logging.debug("Ollama: Submitting request to API endpoint")
+            print("Ollama: Submitting request to API endpoint")
+            try:
+                response = requests.post(api_url, headers=headers, json=data_payload, timeout=30)
+                response.raise_for_status()  # Raises HTTPError for bad responses
+                response_data = response.json()
+            except requests.exceptions.Timeout:
+                logging.error("Ollama: Request timed out.")
+                return "Ollama: Request timed out."
+            except requests.exceptions.HTTPError as http_err:
+                logging.error(f"Ollama: HTTP error occurred: {http_err}")
+                return f"Ollama: HTTP error occurred: {http_err}"
+            except requests.exceptions.RequestException as req_err:
+                logging.error(f"Ollama: Request exception: {req_err}")
+                return f"Ollama: Request exception: {req_err}"
+            except json.JSONDecodeError:
+                logging.error("Ollama: Failed to decode JSON response")
+                return "Ollama: Failed to decode JSON response."
+            except Exception as e:
+                logging.error(f"Ollama: An unexpected error occurred: {str(e)}")
+                return f"Ollama: An unexpected error occurred: {str(e)}"
+
+            logging.debug(f"API Response Data: {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}"
+            if response.status_code == 200:
+                # Inspect available keys
+                available_keys = list(response_data.keys())
+                logging.debug(f"Ollama: Available keys in response: {available_keys}")
+
+                # Attempt to retrieve 'response'
+                summary = None
+                if 'response' in response_data and response_data['response']:
+                    summary = response_data['response'].strip()
+                elif 'choices' in response_data and len(response_data['choices']) > 0:
+                    choice = response_data['choices'][0]
+                    if 'message' in choice and 'content' in choice['message']:
+                        summary = choice['message']['content'].strip()
+
+                if summary:
+                    logging.debug("Ollama: Chat request successful")
+                    print("\n\nChat request successful.")
+                    return summary
+                elif response_data.get('done_reason') == 'load':
+                    logging.warning(f"Ollama: Model is loading. Attempt {attempt} of {max_retries}. Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                else:
+                    logging.error("Ollama: API response does not contain 'response' or 'choices'.")
+                    return "Ollama: API response does not contain 'response' or 'choices'."
+            else:
+                logging.error(f"Ollama: API request failed with status code {response.status_code}: {response.text}")
+                return f"Ollama: API request failed: {response.text}"
+
+        logging.error("Ollama: Maximum retry attempts reached. Model is still loading.")
+        return "Ollama: Maximum retry attempts reached. Model is still loading."
 
     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)}"
+        return f"Ollama: Error occurred while processing summary with Ollama: {str(e)}"
+
 
 def chat_with_vllm(
         input_data: Union[str, dict, list],

App_Function_Libraries/Prompt_Handling.py

@@ -5,6 +5,8 @@ import tempfile
 import zipfile
 import re
 
+from App_Function_Libraries.Utils.Utils import get_database_path
+
 
 def import_prompt_from_file(file):
     if file is None:
@@ -78,7 +80,7 @@ def import_prompt_data(name, details, system, user):
         return "Name and System fields are required."
 
     try:
-        conn = sqlite3.connect('prompts.db')
+        conn = sqlite3.connect(get_database_path('prompts.db'))
         cursor = conn.cursor()
         cursor.execute('''
             INSERT INTO Prompts (name, details, system, user)