add reasoner

app.py

@@ -3,10 +3,20 @@ import random
 import time
 import hmac
 import os
+from llm_reasoner import LLMReasoner
+from prompts import templates
 
 st.header(" Scientific Claim Verification ")
 st.caption("Team UMBC-SBU-UT")
 
+def safe_parse_json(model_answer):
+    """.."""
+    try:
+        return json.loads(model_answer)
+    except json.JSONDecodeError as e:
+        logger.error("Failed to parse JSON: %s", e)
+        return None
+
 def check_password():
     """Returns `True` if the user had a correct password."""
 
@@ -114,7 +124,7 @@ for message in st.session_state.messages:
     with st.chat_message(message["role"]):
         st.markdown(message["content"])
 
-def retriever(query: str):
+def retriever(query: str, selected_retriever: str):
     """Simulate a 'retriever' step, searching for relevant information."""
     with st.chat_message("assistant"):
         placeholder = st.empty()
@@ -137,7 +147,7 @@ def retriever(query: str):
     # You could return retrieved info here.
     return message
 
-def reasoner(info: list[str]):
+def reasoner(query: str, documents: list[str], llm_client: Any):
     """Simulate a 'reasoner' step, thinking about how to answer."""
     with st.chat_message("assistant"):
         placeholder = st.empty()
@@ -150,6 +160,17 @@ def reasoner(info: list[str]):
         else:
             message = "Using o3-mini to quickly analyze the claim..."
 
+        if not documents:
+            prompt = templates["no_evidence"].format(claim=query)
+            llm_response = llm_client.run_inference(prompt)
+
+        message = message + '\n' + llm_response
+
+        answer_dict = safe_parse_json(llm_response)
+        decision = answer_dict.get("decision", "")
+
+        message = message + '\n' + decision
+
         for chunk in message.split():
             text += chunk + " "
             time.sleep(0.05)
@@ -162,15 +183,34 @@ def reasoner(info: list[str]):
 # Accept user input
 if prompt := st.chat_input("Type here"):
     # Add user message to chat history
-    prompt= prompt + "  \n"+ "  \n"+ f"Retriever: {selected_retriever}, Reasoner: {selected_reasoner}"
+    prompt = prompt + "  \n"+ "  \n"+ f"Retriever: {selected_retriever}, Reasoner: {selected_reasoner}"
     st.session_state.messages.append({"role": "user", "content": prompt})
     # Display user message in chat message container
     with st.chat_message("user"):
         st.markdown(prompt)
 
+    options = {}
+    options["max_tokens"] = 500
+    options["temperature"] = 0.0
+
+    if selected_reasoner == "Claude Sonnet":
+        api_key = os.getenv(st.session_state["claude_key"])
+        options["API_KEY"] = api_key
+        options["model_family"] = "Anthropic"
+        options["model_name"] = "claude-3-5-sonnet-20240620"
+
+    elif selected_reasoner == "GPT-4o":
+        api_key = os.getenv(st.session_state["openai_key"])
+        options["API_KEY"] = api_key
+        options["model_family"] = "OpenAI"
+        options["model_name"] = "gpt-4o-2024-05-13"
+
+    
+    llm_client = LLMReasoner(api_key)
+
 
-    retrieved_documents=retriever(prompt)
-    reasoning = reasoner(retrieved_documents)
+    retrieved_documents = retriever(prompt)
+    reasoning = reasoner(prompt, retrieved_documents, llm_client)
 
     # Display assistant response in chat message container
     with st.chat_message("assistant"):

llm_reasoner.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+__author__ = "Yash Kumar Lal, Github@ykl7"
+
+import os
+import openai
+from openai import OpenAI
+import anthropic
+import time
+import random
+from config import config
+
+random.seed(1234)
+
+class LLMReasoner():
+
+    def __init__(self, options):
+
+        if options["model_family"] == "OpenAI":
+            self.client = OpenAI(api_key=options["API_KEY"])
+        elif options["model_family"] == "Anthropic":
+            os.environ["ANTHROPIC_API_KEY"] = options["API_KEY"]
+            self.client = anthropic.Anthropic()
+
+        self.model_family = options["model_family"]
+        self.model_name = options["model_name"]
+        self.max_tokens = options["max_tokens"]
+        self.temp = 0.0 if "temperature" not in options else options["temperature"]
+        self.top_p = 1.0 if "top_p" not in options else options["top_p"]
+        self.frequency_penalty = 0.0 if "frequency_penalty" not in options else options["frequency_penalty"]
+        self.presence_penalty = 0.0 if "presence_penalty" not in options else options["presence_penalty"]
+
+    def make_openai_chat_completions_api_call(self, prompt):
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=prompt,
+                temperature=self.temp,
+                #max_completion_tokens=self.max_tokens,
+                top_p=self.top_p,
+                frequency_penalty=self.frequency_penalty,
+                presence_penalty=self.presence_penalty
+            )
+            return self.parse_chat_completions_api_response(response)
+        except openai.APIConnectionError as e:
+            print("The server could not be reached")
+            print(e.__cause__)  # an underlying Exception, likely raised within httpx.
+            time.sleep(60)
+            return self.make_openai_api_call(prompt)
+        except openai.RateLimitError as e:
+            print("Rate limit error hit")
+            exit()
+        except openai.NotFoundError as e:
+            print("Model not found")
+            exit()
+        except openai.APIStatusError as e:
+            print("Another non-200-range status code was received")
+            print(e.status_code)
+            print(e.response.data)
+            time.sleep(60)
+            return self.make_openai_api_call(prompt)
+
+    def parse_chat_completions_api_response(self, response):
+        # print(response.model_dump())
+        choices = response.choices
+        main_response = choices[0].message
+        main_response_message, main_response_role = main_response.content, main_response.role
+        return main_response_message, response
+
+    def call_claude(self, claude_prompt=""):
+        try:
+            message = self.client.messages.create(
+                model=self.model_name,
+                max_tokens=self.max_tokens,
+                temperature=self.temp,
+                system="",
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": claude_prompt
+                            }
+                        ]
+                    }
+                ]
+            )
+        except Exception as e:
+            breakpoint()
+            print(e)
+            time.sleep(30)
+            call_claude(self, claude_prompt)
+        if message.content[0].type == "text":
+            return message.content[0].text, message
+        else:
+            return "Error", message
+
+    def run_inference(self, prompt=[]):
+
+        if self.model_family == "OpenAI":
+            response_text, response = self.make_openai_chat_completions_api_call(prompt)
+        elif self.model_family == "Anthropic":
+            response_text, response = self.call_claude(prompt)
+
+        return response_text

prompts.py

@@ -0,0 +1,18 @@
+templates = {
+	"no_evidence": """
+	You are an AI model tasked with verifying claims related to medical and health topics using zero-shot learning. Your job is to analyze a given claim and decide whether the available evidence and your general medical knowledge would likely SUPPORT or CONTRADICT the claim.
+Claim to Evaluate: <claim> {claim} </claim>
+Guidelines:
+Evaluate the claim's plausibility based on general medical knowledge.
+Consider the specificity and credibility of any numbers or percentages.
+Analyze the context and scope of the claim.
+Assess any potential biases or limitations.
+Output Format:
+After your analysis, output exactly one JSON object with two keys:
+\"reasoning\": A brief explanation (one or two sentences).
+\"decision\": Either \"SUPPORT\" or \"CONTRADICT\" (uppercase, no additional text).
+Do not add markdown formatting, code fences, or additional text. The output must start with { and end with }.
+Example Output: {\"reasoning\": \"Your brief explanation here (one or two sentences).\", \"decision\": \"SUPPORT or CONTRADICT\"}
+Now, please evaluate the claim above.
+"""
+}