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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cat-llm
-Version: 0.0.68
+Version: 0.0.69
 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
@@ -29,7 +29,7 @@ Description-Content-Type: text/markdown
 
 ![catllm Logo](https://github.com/chrissoria/cat-llm/blob/main/images/logo.png?raw=True)
 
-# catllm
+# cat-llm
 
 [![PyPI - Version](https://img.shields.io/pypi/v/cat-llm.svg)](https://pypi.org/project/cat-llm)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cat-llm.svg)](https://pypi.org/project/cat-llm)

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

@@ -1,16 +1,19 @@
 catllm/CERAD_functions.py,sha256=q4HbP5e2Yu8NnZZ-2eX4sImyj6u3i8xWcq0pYU81iis,22676
-catllm/__about__.py,sha256=i__BfDO7vMnAnfpLD_eRpelQtqul4YDGjfKMTP7PM3Y,430
+catllm/__about__.py,sha256=qQkN04YWoxAJ5HglANO-XGwexy9aL_qFoZSv_CueaUs,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/model_reference_list.py,sha256=bakqZinbGCyY_SBJJIyBLnosKvJuna6B6TWne7YHfC8,2202
-catllm/text_functions.py,sha256=nVXB6Z7_AYXZoXuApu5GoE4anSOtHz1Y6t71OBSyRQI,39408
+catllm/model_reference_list.py,sha256=37pWwMcgnf4biE3BVRluH5oz2P6ccdJJiCVNHodBH8k,2307
+catllm/text_functions.py,sha256=Vd9tAPDCDEhoXVW6O-jXeftJiZQmsyyrKeEUneYeobw,32533
+catllm/calls/CoVe.py,sha256=Y9OGJbaeJ3Odwira92cPXUlnm_ADFqvpOSFSNjFzMMU,10847
+catllm/calls/__init__.py,sha256=fWuMwLeSGa6zXJYd4s8IyNblsD62G-1NMUsOKrNIkoI,725
+catllm/calls/all_calls.py,sha256=E25KpZ_MakMDeCpNCOOM8kQvlfex6UMjnGN1wHkA4AI,14356
 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.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,,
+cat_llm-0.0.69.dist-info/METADATA,sha256=E2q6apmvq1sDDiisnfyyQZzxqjNnqjCSecpalb5MgWQ,22424
+cat_llm-0.0.69.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cat_llm-0.0.69.dist-info/licenses/LICENSE,sha256=Vje2sS5WV4TnIwY5uQHrF4qnBAM3YOk1pGpdH0ot-2o,34969
+cat_llm-0.0.69.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.68"
+__version__ = "0.0.69"
 __author__ = "Chris Soria"
 __email__ = "chrissoria@berkeley.edu"
 __title__ = "cat-llm"

catllm/calls/CoVe.py

@@ -0,0 +1,304 @@
+# openai chain of verification calls
+
+def chain_of_verification_openai(
+    initial_reply,
+    step2_prompt,
+    step3_prompt,
+    step4_prompt,
+    client,
+    user_model,
+    creativity,
+    remove_numbering
+):
+    """
+    Execute Chain of Verification (CoVe) process.
+    Returns the verified reply or initial reply if error occurs.
+    """
+    try:
+        # 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 {})
+        )
+        
+        verified_reply = final_response.choices[0].message.content
+        print("Chain of verification completed. Final response generated.\n")
+        
+        return verified_reply
+        
+    except Exception as e:
+        print(f"ERROR in Chain of Verification: {str(e)}")
+        print("Falling back to initial response.\n")
+        return initial_reply
+    
+# anthropic chain of verification calls
+
+def chain_of_verification_anthropic(
+    initial_reply,
+    step2_prompt,
+    step3_prompt,
+    step4_prompt,
+    client,
+    user_model,
+    creativity,
+    remove_numbering
+):
+    """
+    Execute Chain of Verification (CoVe) process for Anthropic Claude.
+    Returns the verified reply or initial reply if error occurs.
+    """
+    try:
+        # 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 {})
+        )
+        
+        verified_reply = final_response.content[0].text
+        print("Chain of verification completed. Final response generated.\n")
+        
+        return verified_reply
+        
+    except Exception as e:
+        print(f"ERROR in Chain of Verification: {str(e)}")
+        print("Falling back to initial response.\n")
+        return initial_reply
+
+# google chain of verification calls
+def chain_of_verification_google(
+    initial_reply,
+    prompt,
+    step2_prompt,
+    step3_prompt,
+    step4_prompt,
+    url,
+    headers,
+    creativity,
+    remove_numbering,
+    make_google_request
+):
+    import time
+    """
+    Execute Chain of Verification (CoVe) process for Google Gemini.
+    Returns the verified reply or initial reply if error occurs.
+    """
+    try:
+        # 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)
+        verified_reply = result_step4["candidates"][0]["content"]["parts"][0]["text"]
+        
+        print("Chain of verification completed. Final response generated.\n")
+        return verified_reply
+        
+    except Exception as e:
+        print(f"ERROR in Chain of Verification: {str(e)}")
+        print("Falling back to initial response.\n")
+        return initial_reply
+    
+# mistral chain of verification calls
+
+def chain_of_verification_mistral(
+    initial_reply,
+    step2_prompt,
+    step3_prompt,
+    step4_prompt,
+    client,
+    user_model,
+    creativity,
+    remove_numbering
+):
+    """
+    Execute Chain of Verification (CoVe) process for Mistral AI.
+    Returns the verified reply or initial reply if error occurs.
+    """
+    try:
+        # 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 {})
+        )
+        
+        verified_reply = final_response.choices[0].message.content
+        print("Chain of verification completed. Final response generated.\n")
+        
+        return verified_reply
+        
+    except Exception as e:
+        print(f"ERROR in Chain of Verification: {str(e)}")
+        print("Falling back to initial response.\n")
+        return initial_reply

catllm/calls/__init__.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2025-present Christopher Soria <chrissoria@berkeley.edu>
+#
+# SPDX-License-Identifier: MIT
+
+from .all_calls import (
+    get_stepback_insight_openai,
+    get_stepback_insight_anthropic,
+    get_stepback_insight_google,
+    get_stepback_insight_mistral,
+    chain_of_verification_openai,
+    chain_of_verification_google,
+    chain_of_verification_anthropic,
+    chain_of_verification_mistral
+)
+
+__all__ = [
+    'get_stepback_insight_openai',
+    'get_stepback_insight_anthropic',
+    'get_stepback_insight_google',
+    'get_stepback_insight_mistral',
+    'chain_of_verification_openai',
+    'chain_of_verification_anthropic',
+    'chain_of_verification_google',
+    'chain_of_verification_mistral',
+]

catllm/calls/all_calls.py

@@ -0,0 +1,433 @@
+# openai stepback prompt
+
+def get_stepback_insight_openai(
+    stepback,
+    api_key,
+    user_model,
+    model_source="openai",
+    creativity=None
+):
+    from openai import OpenAI
+    # 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
+    )
+    
+    client = OpenAI(api_key=api_key, base_url=base_url)
+    
+    try:
+        stepback_response = client.chat.completions.create(
+            model=user_model,
+            messages=[{'role': 'user', 'content': stepback}],
+            **({"temperature": creativity} if creativity is not None else {})
+        )
+        stepback_insight = stepback_response.choices[0].message.content
+        
+        return stepback_insight, True
+        
+    except Exception as e:
+        print(f"An error occurred during step-back prompting: {e}")
+        return None, False
+
+
+# claude stepback prompt
+
+def get_stepback_insight_anthropic(
+    stepback,
+    api_key,
+    user_model,
+    model_source="anthropic",
+    creativity=None
+):
+    import anthropic
+
+    client = anthropic.Anthropic(api_key=api_key)
+    
+    try:
+        stepback_response = client.messages.create(
+            model=user_model,
+            max_tokens=4096,
+            messages=[{'role': 'user', 'content': stepback}],
+            **({"temperature": creativity} if creativity is not None else {})
+        )
+        stepback_insight = stepback_response.content[0].text
+        
+        return stepback_insight, True
+        
+    except Exception as e:
+        print(f"An error occurred during step-back prompting: {e}")
+        return None, False
+    
+# google stepback prompt
+
+def get_stepback_insight_google(
+    stepback,
+    api_key,
+    user_model,
+    model_source="google",
+    creativity=None
+):
+    
+    import requests
+    
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{user_model}:generateContent?key={api_key}"
+    
+    headers = {
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "contents": [{
+            "parts": [{"text": stepback}],
+
+            **({"generationConfig": {"temperature": creativity}} if creativity is not None else {})
+        }]
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=payload)
+        response.raise_for_status()  # Raise error for bad status codes
+        
+        result = response.json()
+        stepback_insight = result['candidates'][0]['content']['parts'][0]['text']
+        
+        return stepback_insight, True
+        
+    except Exception as e:
+        print(f"An error occurred during step-back prompting: {e}")
+        return None, False
+
+# mistral stepback prompt
+
+def get_stepback_insight_mistral(
+    stepback,
+    api_key,
+    user_model,
+    model_source="mistral",
+    creativity=None
+):
+    
+    from mistralai import Mistral
+    
+    client = Mistral(api_key=api_key)
+    
+    try:
+        stepback_response = client.chat.complete(
+            model=user_model,
+            messages=[{'role': 'user', 'content': stepback}],
+            **({"temperature": creativity} if creativity is not None else {})
+        )
+        stepback_insight = stepback_response.choices[0].message.content
+        
+        return stepback_insight, True
+        
+    except Exception as e:
+        print(f"An error occurred during step-back prompting: {e}")
+        return None, False
+    
+# openai chain of verification calls
+
+def chain_of_verification_openai(
+    initial_reply,
+    step2_prompt,
+    step3_prompt,
+    step4_prompt,
+    client,
+    user_model,
+    creativity,
+    remove_numbering
+):
+    """
+    Execute Chain of Verification (CoVe) process.
+    Returns the verified reply or initial reply if error occurs.
+    """
+    try:
+        # 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 {})
+        )
+        
+        verified_reply = final_response.choices[0].message.content
+        print("Chain of verification completed. Final response generated.\n")
+        
+        return verified_reply
+        
+    except Exception as e:
+        print(f"ERROR in Chain of Verification: {str(e)}")
+        print("Falling back to initial response.\n")
+        return initial_reply
+    
+# anthropic chain of verification calls
+
+def chain_of_verification_anthropic(
+    initial_reply,
+    step2_prompt,
+    step3_prompt,
+    step4_prompt,
+    client,
+    user_model,
+    creativity,
+    remove_numbering
+):
+    """
+    Execute Chain of Verification (CoVe) process for Anthropic Claude.
+    Returns the verified reply or initial reply if error occurs.
+    """
+    try:
+        # 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 {})
+        )
+        
+        verified_reply = final_response.content[0].text
+        print("Chain of verification completed. Final response generated.\n")
+        
+        return verified_reply
+        
+    except Exception as e:
+        print(f"ERROR in Chain of Verification: {str(e)}")
+        print("Falling back to initial response.\n")
+        return initial_reply
+
+# google chain of verification calls
+def chain_of_verification_google(
+    initial_reply,
+    prompt,
+    step2_prompt,
+    step3_prompt,
+    step4_prompt,
+    url,
+    headers,
+    creativity,
+    remove_numbering,
+    make_google_request
+):
+    import time
+    """
+    Execute Chain of Verification (CoVe) process for Google Gemini.
+    Returns the verified reply or initial reply if error occurs.
+    """
+    try:
+        # 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)
+        verified_reply = result_step4["candidates"][0]["content"]["parts"][0]["text"]
+        
+        print("Chain of verification completed. Final response generated.\n")
+        return verified_reply
+        
+    except Exception as e:
+        print(f"ERROR in Chain of Verification: {str(e)}")
+        print("Falling back to initial response.\n")
+        return initial_reply
+    
+# mistral chain of verification calls
+
+def chain_of_verification_mistral(
+    initial_reply,
+    step2_prompt,
+    step3_prompt,
+    step4_prompt,
+    client,
+    user_model,
+    creativity,
+    remove_numbering
+):
+    """
+    Execute Chain of Verification (CoVe) process for Mistral AI.
+    Returns the verified reply or initial reply if error occurs.
+    """
+    try:
+        # 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 {})
+        )
+        
+        verified_reply = final_response.choices[0].message.content
+        print("Chain of verification completed. Final response generated.\n")
+        
+        return verified_reply
+        
+    except Exception as e:
+        print(f"ERROR in Chain of Verification: {str(e)}")
+        print("Falling back to initial response.\n")
+        return initial_reply

catllm/model_reference_list.py

@@ -73,6 +73,7 @@ mistral_models = [
 ]
 
 # meta list of models
+# list can be found here: https://huggingface.co/collections/meta-llama/llama-4-67f0c30d9fe03840bc9d0164
 meta_llama_models = [
     "meta/llama-3.1-8b-instruct",
     "meta/llama-3.1-70b-instruct",

catllm/text_functions.py

@@ -1,3 +1,15 @@
+from .calls.all_calls import (
+    get_stepback_insight_openai,
+    get_stepback_insight_anthropic,
+    get_stepback_insight_google,
+    get_stepback_insight_mistral,
+    chain_of_verification_openai,
+    chain_of_verification_google,
+    chain_of_verification_anthropic,
+    chain_of_verification_mistral
+)
+
+
 #extract categories from corpus
 def explore_corpus(
     survey_question, 
@@ -244,13 +256,15 @@ def multi_class(
     example4 = None,
     example5 = None,
     example6 = None,
-    creativity=None,
-    safety=False,
-    to_csv=False,
-    chain_of_verification=False,
-    filename="categorized_data.csv",
-    save_directory=None,
-    model_source="auto"
+    creativity = None,
+    safety = False,
+    to_csv = False,
+    chain_of_verification = False,
+    step_back_prompt = False,
+    context_prompt = False,
+    filename = "categorized_data.csv",
+    save_directory = None,
+    model_source = "auto"
 ):
     import os
     import json
@@ -331,6 +345,49 @@ def multi_class(
     else:
         survey_question_context = ""
 
+    # step back insight initializationif step_back_prompt:
+    if step_back_prompt:
+        if survey_question == "": # step back requires the survey question to function well
+            raise TypeError("survey_question is required when using step_back_prompt. Please provide the survey question you are analyzing.")
+                
+        stepback = f"""What are the underlying factors or dimensions that explain how people typically answer "{survey_question}"?"""
+
+        if model_source in ["openai", "perplexity", "huggingface"]:
+            stepback_insight, step_back_added = get_stepback_insight_openai(
+                stepback=stepback,
+                api_key=api_key,
+                user_model=user_model,
+                model_source=model_source,
+                creativity=creativity
+            )
+        elif model_source == "anthropic":
+            stepback_insight, step_back_added = get_stepback_insight_anthropic(
+                stepback=stepback,
+                api_key=api_key,
+                user_model=user_model,
+                model_source=model_source,
+                creativity=creativity
+            )
+        elif model_source == "google":
+            stepback_insight, step_back_added = get_stepback_insight_google(
+                stepback=stepback,
+                api_key=api_key,
+                user_model=user_model,
+                model_source=model_source,
+                creativity=creativity
+            )
+        elif model_source == "mistral":
+            stepback_insight, step_back_added = get_stepback_insight_mistral(
+                stepback=stepback,
+                api_key=api_key,
+                user_model=user_model,
+                model_source=model_source,
+                creativity=creativity
+            )
+    else:
+        stepback_insight = None
+        step_back_added = False
+
     for idx, response in enumerate(tqdm(survey_input, desc="Categorizing responses")):
         reply = None  
 
@@ -347,6 +404,14 @@ def multi_class(
             {examples_text}
             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 context_prompt:
+                context = """You are an expert researcher in survey data categorization. 
+                Apply multi-label classification and base decisions on explicit and implicit meanings. 
+                When uncertain, prioritize precision over recall."""
+
+                prompt = context + prompt
+                print(prompt)
+
             if chain_of_verification:
                 step2_prompt = f"""You provided this initial categorization:
                 <<INITIAL_REPLY>>
@@ -384,7 +449,7 @@ def multi_class(
                 If no categories are present, assign "0" to all categories.
                 Provide the final corrected categorization in the same JSON format:"""
 
-
+            # Main model interaction
             if model_source in ["openai", "perplexity", "huggingface"]:
                 from openai import OpenAI
                 from openai import OpenAI, BadRequestError, AuthenticationError
@@ -398,73 +463,33 @@ def multi_class(
                 client = OpenAI(api_key=api_key, base_url=base_url)
                 
                 try:
+                    messages = [
+                        *([{'role': 'user', 'content': stepback}] if step_back_prompt and step_back_added else []), # only if step back is enabled and successful
+                        *([{'role': 'assistant', 'content': stepback_insight}] if step_back_added else {}), # include insight if step back succeeded
+                        {'role': 'user', 'content': prompt}
+                    ]
+
                     response_obj = client.chat.completions.create(
                     model=user_model,
-                    messages=[{'role': 'user', 'content': prompt}],
+                    messages=messages,
                     **({"temperature": creativity} if creativity is not None else {})
                     )
         
                     reply = response_obj.choices[0].message.content
                     
                     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)
+                        reply = chain_of_verification_openai(
+                            initial_reply=reply,
+                            step2_prompt=step2_prompt,
+                            step3_prompt=step3_prompt,
+                            step4_prompt=step4_prompt,
+                            client=client,
+                            user_model=user_model,
+                            creativity=creativity,
+                            remove_numbering=remove_numbering
+                        )
 
-                        except Exception as e:
-                            print(f"ERROR in Chain of Verification: {str(e)}")
-                            print("Falling back to initial response.\n")
-                            link1.append(reply)
+                        link1.append(reply)
                     else:
                         #if chain of verification is not enabled, just append initial reply
                         link1.append(reply)
@@ -492,68 +517,18 @@ def multi_class(
                     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)
+                        reply = chain_of_verification_anthropic(
+                            initial_reply=reply,
+                            step2_prompt=step2_prompt,
+                            step3_prompt=step3_prompt,
+                            step4_prompt=step4_prompt,
+                            client=client,
+                            user_model=user_model,
+                            creativity=creativity,
+                            remove_numbering=remove_numbering
+                        )
 
-                        except Exception as e:
-                            print(f"ERROR in Chain of Verification: {str(e)}")
-                            print("Falling back to initial response.\n")
-                            link1.append(reply)
+                        link1.append(reply)
                     else:
                         #if chain of verification is not enabled, just append initial reply
                         link1.append(reply)
@@ -605,71 +580,20 @@ def multi_class(
                         reply = "No response generated"
 
                     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")
+                        reply = chain_of_verification_google(
+                            initial_reply=reply,
+                            prompt=prompt,
+                            step2_prompt=step2_prompt,
+                            step3_prompt=step3_prompt,
+                            step4_prompt=step4_prompt,
+                            url=url,
+                            headers=headers,
+                            creativity=creativity,
+                            remove_numbering=remove_numbering,
+                            make_google_request=make_google_request
+                        )
 
-                            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
@@ -703,59 +627,19 @@ def multi_class(
                     reply = response.choices[0].message.content
                     
                     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")
+                        reply = chain_of_verification_mistral(
+                            initial_reply=reply,
+                            step2_prompt=step2_prompt,
+                            step3_prompt=step3_prompt,
+                            step4_prompt=step4_prompt,
+                            client=client,
+                            user_model=user_model,
+                            creativity=creativity,
+                            remove_numbering=remove_numbering
+                        )
+
+                        link1.append(reply)
+
                     else:
                         #if chain of verification is not enabled, just append initial reply
                         link1.append(reply)
@@ -832,6 +716,25 @@ def multi_class(
         'json': pd.Series(extracted_jsons).reset_index(drop=True)
     })
     categorized_data = pd.concat([categorized_data, normalized_data], axis=1)
+    categorized_data = categorized_data.rename(columns=lambda x: f'category_{x}' if str(x).isdigit() else x)
+
+    #converting to numeric
+    cat_cols = [col for col in categorized_data.columns if col.startswith('category_')]
+
+    categorized_data['processing_status'] = np.where(
+        categorized_data[cat_cols].isna().all(axis=1), 
+        'error', 
+        'success'
+    )
+
+    categorized_data.loc[categorized_data[cat_cols].apply(pd.to_numeric, errors='coerce').isna().any(axis=1), cat_cols] = np.nan
+    categorized_data[cat_cols] = categorized_data[cat_cols].astype('Int64')
+
+    categorized_data['categories_present'] = categorized_data[cat_cols].apply(
+        lambda x: ','.join(x.dropna().astype(str)), axis=1
+    )
+
+    categorized_data['categories_counted'] = categorized_data[cat_cols].count(axis=1)
 
     if to_csv:
         if save_directory is None: