cat-llm 0.0.67__py3-none-any.whl → 0.0.68__py3-none-any.whl

{cat_llm-0.0.67.dist-info → cat_llm-0.0.68.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cat-llm
-Version: 0.0.67
+Version: 0.0.68
 Summary: A tool for categorizing text data and images using LLMs and vision models
 Project-URL: Documentation, https://github.com/chrissoria/cat-llm#readme
 Project-URL: Issues, https://github.com/chrissoria/cat-llm/issues

{cat_llm-0.0.67.dist-info → cat_llm-0.0.68.dist-info}/RECORD

@@ -1,15 +1,16 @@
 catllm/CERAD_functions.py,sha256=q4HbP5e2Yu8NnZZ-2eX4sImyj6u3i8xWcq0pYU81iis,22676
-catllm/__about__.py,sha256=hIVt-fQydvImRffcCyiHlTFeOR5F2aEchTWXAsWTPc4,430
+catllm/__about__.py,sha256=i__BfDO7vMnAnfpLD_eRpelQtqul4YDGjfKMTP7PM3Y,430
 catllm/__init__.py,sha256=sf02zp7N0NW0mAQi7eQ4gliWR1EwoqvXkHN2HwwjcTE,372
 catllm/build_web_research.py,sha256=880dfE2bEQb-FrXP-42JoLLtyc9ox_sBULDr38xiTiQ,22655
 catllm/image_functions.py,sha256=8_FftRU285x1HT-AgNkaobefQVD-5q7ZY_t7JFdL3Sg,36177
-catllm/text_functions.py,sha256=_GMretLVBUs0ntL-wV6My0TRAvzvaPo_WU9ZqXlKxeM,19426
+catllm/model_reference_list.py,sha256=bakqZinbGCyY_SBJJIyBLnosKvJuna6B6TWne7YHfC8,2202
+catllm/text_functions.py,sha256=nVXB6Z7_AYXZoXuApu5GoE4anSOtHz1Y6t71OBSyRQI,39408
 catllm/images/circle.png,sha256=JWujAWAh08-TajAoEr_TAeFNLlfbryOLw6cgIBREBuQ,86202
 catllm/images/cube.png,sha256=nFec3e5bmRe4zrBCJ8QK-HcJLrG7u7dYdKhmdMfacfE,77275
 catllm/images/diamond.png,sha256=rJDZKtsnBGRO8FPA0iHuA8FvHFGi9PkI_DWSFdw6iv0,99568
 catllm/images/overlapping_pentagons.png,sha256=VO5plI6eoVRnjfqinn1nNzsCP2WQhuQy71V0EASouW4,71208
 catllm/images/rectangles.png,sha256=2XM16HO9EYWj2yHgN4bPXaCwPfl7iYQy0tQUGaJX9xg,40692
-cat_llm-0.0.67.dist-info/METADATA,sha256=UR95eJdArTmJe6A2g2hH0Q9mZ9PkEQsJ2kVSg3KfQe4,22423
-cat_llm-0.0.67.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cat_llm-0.0.67.dist-info/licenses/LICENSE,sha256=Vje2sS5WV4TnIwY5uQHrF4qnBAM3YOk1pGpdH0ot-2o,34969
-cat_llm-0.0.67.dist-info/RECORD,,
+cat_llm-0.0.68.dist-info/METADATA,sha256=Z3SgZqkNNc8LW_eBc6Q8WmIXp0v2Qpjbjevz3kM4o_M,22423
+cat_llm-0.0.68.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cat_llm-0.0.68.dist-info/licenses/LICENSE,sha256=Vje2sS5WV4TnIwY5uQHrF4qnBAM3YOk1pGpdH0ot-2o,34969
+cat_llm-0.0.68.dist-info/RECORD,,

catllm/__about__.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2025-present Christopher Soria <chrissoria@berkeley.edu>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.0.67"
+__version__ = "0.0.68"
 __author__ = "Chris Soria"
 __email__ = "chrissoria@berkeley.edu"
 __title__ = "cat-llm"

catllm/model_reference_list.py

@@ -0,0 +1,93 @@
+# openai list of models
+openai_models = [
+    "gpt-5",
+    "gpt-5-mini",
+    "gpt-5-nano",
+    "gpt-4o",
+    "gpt-4o-mini",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-3.5-turbo",
+    "text-davinci-003",
+    "text-davinci-002"
+]
+
+#  anthropic list of models
+anthropic_models = [
+    "claude-opus-4-20250514-v1:0",
+    "claude-opus-4-1-20250805-v1:0",
+    "claude-sonnet-4-5-20250929-v1:0",
+    "claude-sonnet-4-20250514-v1:0",
+    "claude-3-7-sonnet-20250219-v1:0",
+    "claude-3-5-sonnet-20240620-v1:0",
+    "claude-3-5-haiku-20241022-v1:0",
+    "claude-3-opus-20240229-v1:0",
+    "claude-3-sonnet-20240229-v1:0",
+    "claude-haiku-4-5-20251001-v1:0",
+    "claude-sonnet-4-5-20250929",
+    "claude-haiku-4-5-20251001",
+    "claude-opus-4-1-20250805"
+]
+
+# google list of models
+
+google_models = [
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+    "gemini-2.5-pro",
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-lite",
+    "gemini-2.0-pro",
+    "gemini-2.5",
+    "gemini-2.0",
+    "gemini-2.5-flash-preview",
+    "gemini-2.5-pro-preview"
+]
+
+# perplexity list of models
+
+perplexity_models = [
+    "sonar",
+    "sonar-pro",
+    "sonar-reasoning",
+    "sonar-reasoning-pro",
+    "sonar-deep-research",
+    "r1-1776"
+]
+
+# mistral list of models
+
+mistral_models = [
+    "mistral-large-latest",
+    "mistral-medium-2505",
+    "mistral-large-2411",
+    "codestral-2501",
+    "pixtral-large-2411",
+    "mistral-small-2407",
+    "mistral-embed",
+    "codestral-embed",
+    "mistral-moderation-2411",
+    "ministral-3b-2410",
+    "ministral-8b-2410"
+]
+
+# meta list of models
+meta_llama_models = [
+    "meta/llama-3.1-8b-instruct",
+    "meta/llama-3.1-70b-instruct",
+    "meta/llama-3.1-405b-instruct",
+    "meta/llama-3.2-11b-vision-instruct",
+    "meta/llama-3.2-90b-vision-instruct",
+    "meta/llama-3.3-70b-instruct",
+    "meta/llama-4-scout-17b-16e-instruct",
+    "meta/llama-4-maverick-17b-128e-instruct",
+    "llama-4-maverick-17b-128e-instruct-maas",
+    "llama-4-scout-17b-16e-instruct-maas",
+    "llama-3.3-70b-instruct-maas",
+    "llama-3.2-90b-vision-instruct-maas",
+    "llama-3.1-405b-instruct-maas",
+    "llama-3.1-70b-instruct-maas",
+    "llama-3.1-8b-instruct-maas",
+
+]

catllm/text_functions.py

@@ -232,12 +232,12 @@ Return the top {top_n} categories as a numbered list sorted from the most to lea
 # GOAL: enable step-back prompting
 # GOAL 2: enable self-consistency
 def multi_class(
-    survey_question, 
     survey_input,
     categories,
     api_key,
     user_model="gpt-5",
     user_prompt = None,
+    survey_question = "",
     example1 = None,
     example2 = None,
     example3 = None,
@@ -247,9 +247,10 @@ def multi_class(
     creativity=None,
     safety=False,
     to_csv=False,
+    chain_of_verification=False,
     filename="categorized_data.csv",
     save_directory=None,
-    model_source="OpenAI"
+    model_source="auto"
 ):
     import os
     import json
@@ -257,7 +258,54 @@ def multi_class(
     import regex
     from tqdm import tqdm
 
+    def remove_numbering(line):
+        line = line.strip()
+    
+        # Handle bullet points
+        if line.startswith('- '):
+            return line[2:].strip()
+        if line.startswith('• '):
+            return line[2:].strip()
+    
+        # Handle numbered lists "1.", "10.", etc.
+        if line and line[0].isdigit():
+            # Find where the number ends
+            i = 0
+            while i < len(line) and line[i].isdigit():
+                i += 1
+        
+            # Check if followed by '.' or ')'
+            if i < len(line) and line[i] in '.':
+                return line[i+1:].strip()
+            elif i < len(line) and line[i] in ')':
+                return line[i+1:].strip()
+    
+        return line
+
     model_source = model_source.lower() # eliminating case sensitivity 
+
+    # auto-detect model source if not provided
+    if model_source is None or model_source == "auto":
+        user_model_lower = user_model.lower()
+    
+        if "gpt" in user_model_lower:
+            model_source = "openai"
+        elif "claude" in user_model_lower:
+            model_source = "anthropic"
+        elif "gemini" in user_model_lower or "gemma" in user_model_lower:
+            model_source = "google"
+        elif "llama" in user_model_lower or "meta" in user_model_lower:
+            model_source = "huggingface"
+        elif "mistral" in user_model_lower or "mixtral" in user_model_lower:
+            model_source = "mistral"
+        elif "sonar" in user_model_lower or "pplx" in user_model_lower:
+            model_source = "perplexity"
+        elif "deepseek"  in user_model_lower or "qwen" in user_model_lower:
+            model_source = "huggingface"
+        else:
+            raise ValueError(f"❌ Could not auto-detect model source from '{user_model}'. Please specify model_source explicitly: OpenAI, Anthropic, Perplexity, Google, Huggingface, or Mistral")
+    else:
+        model_source = model_source.lower()
     
     categories_str = "\n".join(f"{i + 1}. {cat}" for i, cat in enumerate(categories))
     cat_num = len(categories)
@@ -265,17 +313,23 @@ def multi_class(
     example_JSON = json.dumps(category_dict, indent=4)
 
     # ensure number of categories is what user wants
-    print("\nThe categories you entered:")
+    print(f"\nThe categories you entered to be coded by {model_source} {user_model}:")
     for i, cat in enumerate(categories, 1):
         print(f"{i}. {cat}")
     
     link1 = []
     extracted_jsons = []
+
     #handling example inputs
     examples = [example1, example2, example3, example4, example5, example6]
     examples_text = "\n".join(
     f"Example {i}: {ex}" for i, ex in enumerate(examples, 1) if ex is not None
 )
+    # allowing users to contextualize the survey question
+    if survey_question != None:
+        survey_question_context = f"A respondent was asked: {survey_question}."
+    else:
+        survey_question_context = ""
 
     for idx, response in enumerate(tqdm(survey_input, desc="Categorizing responses")):
         reply = None  
@@ -287,58 +341,248 @@ def multi_class(
             #print(f"Skipped NaN input.")
         else:
 
-            prompt = f"""A respondent was asked: {survey_question}. \
+            prompt = f"""{survey_question_context} \
             Categorize this survey response "{response}" into the following categories that apply: \
             {categories_str}
             {examples_text}
-            Provide your work in JSON format..."""
+            Provide your work in JSON format where the number belonging to each category is the key and a 1 if the category is present and a 0 if it is not present as key values."""
+
+            if chain_of_verification:
+                step2_prompt = f"""You provided this initial categorization:
+                <<INITIAL_REPLY>>
+                
+                Original task: {prompt}
+                
+                Generate a focused list of 3-5 verification questions to fact-check your categorization. Each question should:
+                - Be concise and specific (one sentence)
+                - Address a distinct aspect of the categorization
+                - Be answerable independently
+
+                Focus on verifying:
+                - Whether each category assignment is accurate
+                - Whether the categories match the criteria in the original task
+                - Whether there are any logical inconsistencies
+
+                Provide only the verification questions as a numbered list."""
+
+                step3_prompt = f"""Answer the following verification question based on the survey response provided.
+
+                Survey response: {response}
+
+                Verification question: <<QUESTION>>
 
-            if model_source == ("openai"):
+                Provide a brief, direct answer (1-2 sentences maximum).
+
+                Answer:"""
+
+
+                step4_prompt = f"""Original task: {prompt}
+                Initial categorization:
+                <<INITIAL_REPLY>>
+                Verification questions and answers:
+                <<VERIFICATION_QA>>
+                If no categories are present, assign "0" to all categories.
+                Provide the final corrected categorization in the same JSON format:"""
+
+
+            if model_source in ["openai", "perplexity", "huggingface"]:
                 from openai import OpenAI
-                client = OpenAI(api_key=api_key)
+                from openai import OpenAI, BadRequestError, AuthenticationError
+                # conditional base_url setting based on model source
+                base_url = (
+                    "https://api.perplexity.ai" if model_source == "perplexity" 
+                    else "https://router.huggingface.co/v1" if model_source == "huggingface"
+                    else None  # default
+                )
+    
+                client = OpenAI(api_key=api_key, base_url=base_url)
+                
                 try:
                     response_obj = client.chat.completions.create(
                     model=user_model,
                     messages=[{'role': 'user', 'content': prompt}],
                     **({"temperature": creativity} if creativity is not None else {})
-                )
-                    reply = response_obj.choices[0].message.content
-                    link1.append(reply)
-                except Exception as e:
-                    print(f"An error occurred: {e}")
-                    link1.append(f"Error processing input: {e}")
-            elif model_source == "perplexity":
-                from openai import OpenAI
-                client = OpenAI(api_key=api_key, base_url="https://api.perplexity.ai")
-                try:
-                    response_obj = client.chat.completions.create(
-                        model=user_model,
-                        messages=[{'role': 'user', 'content': prompt}],
-                        **({"temperature": creativity} if creativity is not None else {})
                     )
+        
                     reply = response_obj.choices[0].message.content
-                    link1.append(reply)
+                    
+                    if chain_of_verification:
+                        try:
+                            initial_reply = reply
+                            #STEP 2: Generate verification questions
+                            step2_filled = step2_prompt.replace('<<INITIAL_REPLY>>', initial_reply)
+
+                            verification_response = client.chat.completions.create(
+                                model=user_model,
+                                messages=[{'role': 'user', 'content': step2_filled}],
+                                **({"temperature": creativity} if creativity is not None else {})
+                                )
+                            
+                            verification_questions = verification_response.choices[0].message.content
+                            #STEP 3: Answer verification questions
+                            questions_list = [
+                                remove_numbering(q) 
+                                for q in verification_questions.split('\n') 
+                                if q.strip()
+                                ]
+                            verification_qa = []
+
+                            #prompting each question individually
+                            for question in questions_list:
+
+                                step3_filled = step3_prompt.replace('<<QUESTION>>', question)
+
+                                answer_response = client.chat.completions.create(
+                                    model=user_model,
+                                    messages=[{'role': 'user', 'content': step3_filled}],
+                                    **({"temperature": creativity} if creativity is not None else {})
+                                    )
+
+                                answer = answer_response.choices[0].message.content
+                                verification_qa.append(f"Q: {question}\nA: {answer}")
+
+                            #STEP 4: Final corrected categorization
+                            verification_qa_text = "\n\n".join(verification_qa)
+                            
+                            step4_filled = (step4_prompt
+                            .replace('<<INITIAL_REPLY>>', initial_reply)
+                            .replace('<<VERIFICATION_QA>>', verification_qa_text))
+
+                            print(f"Final prompt:\n{step4_filled}\n")
+
+                            final_response = client.chat.completions.create(
+                                model=user_model,
+                                messages=[{'role': 'user', 'content': step4_filled}],
+                                **({"temperature": creativity} if creativity is not None else {})
+                            )
+
+                            reply = final_response.choices[0].message.content
+    
+                            print("Chain of verification completed. Final response generated.\n")
+                            link1.append(reply)
+
+                        except Exception as e:
+                            print(f"ERROR in Chain of Verification: {str(e)}")
+                            print("Falling back to initial response.\n")
+                            link1.append(reply)
+                    else:
+                        #if chain of verification is not enabled, just append initial reply
+                        link1.append(reply)
+                    
+                except BadRequestError as e:
+                    # Model doesn't exist - halt immediately
+                    raise ValueError(f"❌ Model '{user_model}' on {model_source} not found. Please check the model name and try again.") from e
                 except Exception as e:
                     print(f"An error occurred: {e}")
                     link1.append(f"Error processing input: {e}")
+
             elif model_source == "anthropic":
+
                 import anthropic
                 client = anthropic.Anthropic(api_key=api_key)
+                
                 try:
-                    message = client.messages.create(
+                    response_obj = client.messages.create(
                     model=user_model,
-                    max_tokens=1024,
-                    **({"temperature": creativity} if creativity is not None else {}),
-                    messages=[{"role": "user", "content": prompt}]
-                )
-                    reply = message.content[0].text  # Anthropic returns content as list
-                    link1.append(reply)
+                    max_tokens=4096,
+                    messages=[{'role': 'user', 'content': prompt}],
+                    **({"temperature": creativity} if creativity is not None else {})
+                    )
+        
+                    reply = response_obj.content[0].text
+                    
+                    if chain_of_verification:
+                        try:
+                            initial_reply = reply
+                            #STEP 2: Generate verification questions
+                            step2_filled = step2_prompt.replace('<<INITIAL_REPLY>>', initial_reply)
+
+                            verification_response = client.messages.create(
+                                model=user_model,
+                                messages=[{'role': 'user', 'content': step2_filled}],
+                                max_tokens=4096,
+                                **({"temperature": creativity} if creativity is not None else {})
+                                )
+                            
+                            verification_questions = verification_response.content[0].text
+                            #STEP 3: Answer verification questions
+                            questions_list = [
+                                remove_numbering(q) 
+                                for q in verification_questions.split('\n') 
+                                if q.strip()
+                                ]
+                            print(f"Verification questions:\n{questions_list}\n")
+                            verification_qa = []
+
+                            #prompting each question individually
+                            for question in questions_list:
+
+                                step3_filled = step3_prompt.replace('<<QUESTION>>', question)
+
+                                answer_response = client.messages.create(
+                                    model=user_model,
+                                    messages=[{'role': 'user', 'content': step3_filled}],
+                                    max_tokens=4096,
+                                    **({"temperature": creativity} if creativity is not None else {})
+                                    )
+
+                                answer = answer_response.content[0].text
+                                verification_qa.append(f"Q: {question}\nA: {answer}")
+
+                            #STEP 4: Final corrected categorization
+                            verification_qa_text = "\n\n".join(verification_qa)
+                            
+                            step4_filled = (step4_prompt
+                            .replace('<<INITIAL_REPLY>>', initial_reply)
+                            .replace('<<VERIFICATION_QA>>', verification_qa_text))
+
+                            print(f"Final prompt:\n{step4_filled}\n")
+
+                            final_response = client.messages.create(
+                                model=user_model,
+                                messages=[{'role': 'user', 'content': step4_filled}],
+                                max_tokens=4096,
+                                **({"temperature": creativity} if creativity is not None else {})
+                            )
+
+                            reply = final_response.content[0].text
+    
+                            print("Chain of verification completed. Final response generated.\n")
+                            link1.append(reply)
+
+                        except Exception as e:
+                            print(f"ERROR in Chain of Verification: {str(e)}")
+                            print("Falling back to initial response.\n")
+                            link1.append(reply)
+                    else:
+                        #if chain of verification is not enabled, just append initial reply
+                        link1.append(reply)
+                    
+                except anthropic.NotFoundError as e:
+                    # Model doesn't exist - halt immediately
+                    raise ValueError(f"❌ Model '{user_model}' on {model_source} not found. Please check the model name and try again.") from e
                 except Exception as e:
                     print(f"An error occurred: {e}")
                     link1.append(f"Error processing input: {e}")
                     
             elif model_source == "google":
                 import requests
+
+                def make_google_request(url, headers, payload, max_retries=3):
+                    """Make Google API request with exponential backoff on 429 errors"""
+                    for attempt in range(max_retries):
+                        try:
+                            response = requests.post(url, headers=headers, json=payload)
+                            response.raise_for_status()
+                            return response.json()
+                        except requests.exceptions.HTTPError as e:
+                            if e.response.status_code == 429 and attempt < max_retries - 1:
+                                wait_time = 10 * (2 ** attempt)
+                                print(f"⚠️ Rate limited. Waiting {wait_time}s...")
+                                time.sleep(wait_time)
+                            else:
+                                raise
+
                 url = f"https://generativelanguage.googleapis.com/v1beta/models/{user_model}:generateContent"
                 try:
                     headers = {
@@ -353,22 +597,100 @@ def multi_class(
                             **({"generationConfig": {"temperature": creativity}} if creativity is not None else {})
                             }
                     
-                    response = requests.post(url, headers=headers, json=payload)
-                    response.raise_for_status()  # Raise exception for HTTP errors
-                    result = response.json()
+                    result = make_google_request(url, headers, payload)
 
                     if "candidates" in result and result["candidates"]:
                         reply = result["candidates"][0]["content"]["parts"][0]["text"]
                     else:
                         reply = "No response generated"
 
-                    link1.append(reply)
+                    if chain_of_verification:
+                        try:
+                            import time
+                            initial_reply = reply
+                            # STEP 2: Generate verification questions
+                            step2_filled = step2_prompt.replace('<<INITIAL_REPLY>>', initial_reply)
+                            
+                            payload_step2 = {
+                                "contents": [{
+                                    "parts": [{"text": step2_filled}]
+                                    }],
+                                    **({"generationConfig": {"temperature": creativity}} if creativity is not None else {})
+                                    }
+                
+                            result_step2 = make_google_request(url, headers, payload_step2)
+                
+                            verification_questions = result_step2["candidates"][0]["content"]["parts"][0]["text"]
+                
+                            # STEP 3: Answer verification questions
+                            questions_list = [
+                                remove_numbering(q) 
+                                for q in verification_questions.split('\n') 
+                                if q.strip()
+                            ]
+                            verification_qa = []
+                            
+                            for question in questions_list:
+                                time.sleep(2) # temporary rate limit handling
+                                step3_filled = step3_prompt.replace('<<QUESTION>>', question)
+                                payload_step3 = {
+                                    "contents": [{
+                                        "parts": [{"text": step3_filled}]
+                                        }],
+                                        **({"generationConfig": {"temperature": creativity}} if creativity is not None else {})
+                                }
+                    
+                                result_step3 = make_google_request(url, headers, payload_step3)
+                    
+                                answer = result_step3["candidates"][0]["content"]["parts"][0]["text"]
+                                verification_qa.append(f"Q: {question}\nA: {answer}")
+                
+                            # STEP 4: Final corrected categorization
+                            verification_qa_text = "\n\n".join(verification_qa)
+                
+                            step4_filled = (step4_prompt
+                            .replace('<<PROMPT>>', prompt)
+                            .replace('<<INITIAL_REPLY>>', initial_reply)
+                            .replace('<<VERIFICATION_QA>>', verification_qa_text))
+                
+                            payload_step4 = {
+                                "contents": [{
+                                    "parts": [{"text": step4_filled}]
+                                    }],
+                            **({"generationConfig": {"temperature": creativity}} if creativity is not None else {})
+                            }
+                
+                            result_step4 = make_google_request(url, headers, payload_step4)
+                
+                            reply = result_step4["candidates"][0]["content"]["parts"][0]["text"]
+                            print("Chain of verification completed. Final response generated.\n")
+
+                            link1.append(reply)
+                
+                        except Exception as e:
+                            print(f"ERROR in Chain of Verification: {str(e)}")
+                            print("Falling back to initial response.\n")
+        
+                    else:
+                        # if chain of verification is not enabled, just append initial reply
+                        link1.append(reply)
+                
+                except requests.exceptions.HTTPError as e:
+                    if e.response.status_code == 404:
+                        raise ValueError(f"❌ Model '{user_model}' not found. Please check the model name and try again.") from e
+                    elif e.response.status_code == 401 or e.response.status_code == 403:
+                        raise ValueError(f"❌ Authentication failed. Please check your Google API key.") from e
+                    else:
+                        print(f"HTTP error occurred: {e}")
+                        link1.append(f"Error processing input: {e}")
                 except Exception as e:
                     print(f"An error occurred: {e}")
                     link1.append(f"Error processing input: {e}")
 
             elif model_source == "mistral":
                 from mistralai import Mistral
+                from mistralai.models import SDKError
+
                 client = Mistral(api_key=api_key)
                 try:
                     response = client.chat.complete(
@@ -379,12 +701,80 @@ def multi_class(
                     **({"temperature": creativity} if creativity is not None else {})
                 )
                     reply = response.choices[0].message.content
-                    link1.append(reply)
+                    
+                    if chain_of_verification:
+                        try:
+                            initial_reply = reply
+                            #STEP 2: Generate verification questions
+                            step2_filled = step2_prompt.replace('<<INITIAL_REPLY>>', initial_reply)
+
+                            verification_response = client.chat.complete(
+                                model=user_model,
+                                messages=[{'role': 'user', 'content': step2_filled}],
+                                **({"temperature": creativity} if creativity is not None else {})
+                                )
+                            
+                            verification_questions = verification_response.choices[0].message.content
+                            #STEP 3: Answer verification questions
+                            questions_list = [
+                                remove_numbering(q) 
+                                for q in verification_questions.split('\n') 
+                                if q.strip()
+                                ]
+                            verification_qa = []
+
+                            #prompting each question individually
+                            for question in questions_list:
+
+                                step3_filled = step3_prompt.replace('<<QUESTION>>', question)
+
+                                answer_response = client.chat.complete(
+                                    model=user_model,
+                                    messages=[{'role': 'user', 'content': step3_filled}],
+                                    **({"temperature": creativity} if creativity is not None else {})
+                                    )
+
+                                answer = answer_response.choices[0].message.content
+                                verification_qa.append(f"Q: {question}\nA: {answer}")
+
+                            #STEP 4: Final corrected categorization
+                            verification_qa_text = "\n\n".join(verification_qa)
+                            
+                            step4_filled = (step4_prompt
+                            .replace('<<INITIAL_REPLY>>', initial_reply)
+                            .replace('<<VERIFICATION_QA>>', verification_qa_text))
+
+                            final_response = client.chat.complete(
+                                model=user_model,
+                                messages=[{'role': 'user', 'content': step4_filled}],
+                                **({"temperature": creativity} if creativity is not None else {})
+                            )
+
+                            reply = final_response.choices[0].message.content
+    
+                            link1.append(reply)
+                        except Exception as e:
+                            print(f"ERROR in Chain of Verification: {str(e)}")
+                            print("Falling back to initial response.\n")
+                    else:
+                        #if chain of verification is not enabled, just append initial reply
+                        link1.append(reply)
+
+                except SDKError as e:
+                    error_str = str(e).lower()
+                    if "invalid_model" in error_str or "invalid model" in error_str:
+                        raise ValueError(f"❌ Model '{user_model}' not found.") from e
+                    elif "401" in str(e) or "unauthorized" in str(e).lower():
+                        raise ValueError(f"❌ Authentication failed. Please check your Mistral API key.") from e
+                    else:
+                        print(f"An error occurred: {e}")
+                        link1.append(f"Error processing input: {e}")
                 except Exception as e:
-                    print(f"An error occurred: {e}")
+                    print(f"An unexpected error occurred: {e}")
                     link1.append(f"Error processing input: {e}")
+
             else:
-                raise ValueError("Unknown source! Choose from OpenAI, Anthropic, Perplexity, or Mistral")
+                raise ValueError("Unknown source! Choose from OpenAI, Anthropic, Perplexity, Google, Huggingface, or Mistral")
             # in situation that no JSON is found
             if reply is not None:
                 extracted_json = regex.findall(r'\{(?:[^{}]|(?R))*\}', reply, regex.DOTALL)