Update app.py

app.py

@@ -3,20 +3,31 @@ import gradio as gr
 import requests
 import os  
 
+def check_hallucination(assertion, citation):
+    api_url = "https://api-inference.huggingface.co/models/vectara/hallucination_evaluation_model"
+    header = {"Authorization": f"Bearer {hf_token}"}
+    payload = {"inputs": f"{assertion} [SEP] {citation}"}
+
+    response = requests.post(api_url, headers=header, json=payload, timeout=120)
+    output = response.json()
+    output = output[0][0]["score"]
+
+    return f"**hallucination score:** {output}"
+
+
 # Define the API parameters
-API_URL = "https://api-inference.huggingface.co/models/vectara/hallucination_evaluation_model"
-API_TOKEN = os.getenv("HF_AUTH_TOKEN")
-if not API_TOKEN:
-    raise ValueError("Please set the HF_AUTH_TOKEN environment variable.")
+vapi_url = "https://api-inference.huggingface.co/models/vectara/hallucination_evaluation_model"
+
+headers = {"Authorization": f"Bearer {hf_token}"}
 
-headers = {"Authorization": f"Bearer {API_TOKEN}"}
 
 # Function to query the API
 def query(payload):
-    response = requests.post(API_URL, headers=headers, json=payload)
+    response = requests.post(vapi_url, headers=headers, json=payload)
     return response.json()
 
-# Function to be called by the Gradio interface
+
+# Function to evaluate hallucination
 def evaluate_hallucination(input1, input2):
     # Combine the inputs
     combined_input = f"{input1}. {input2}"
@@ -27,11 +38,117 @@ def evaluate_hallucination(input1, input2):
     # Extract the score from the output
     score = output[0][0]['score']
     
-    # Return a red or green circle based on the score
+    # Generate a label based on the score
     if score < 0.5:
-        return "🔴", "The score is less than 0.5"
+        label = f"🔴 High risk. Score: {score:.2f}"
+    else:
+        label = f"🟢 Low risk. Score: {score:.2f}"
+    
+    return label
+
+def query_vectara(text):
+    user_message = text
+
+    # Read authentication parameters from the .env file
+    customer_id = os.getenv('CUSTOMER_ID')
+    corpus_id = os.getenv('CORPUS_ID')
+    api_key = os.getenv('API_KEY')
+
+    # Define the headers
+    api_key_header = {
+        "customer-id": customer_id,
+        "x-api-key": api_key
+    }
+
+    # Define the request body in the structure provided in the example
+    request_body = {
+        "query": [
+            {
+                "query": user_message,
+                "queryContext": "",
+                "start": 1,
+                "numResults": 25,
+                "contextConfig": {
+                    "charsBefore": 0,
+                    "charsAfter": 0,
+                    "sentencesBefore": 2,
+                    "sentencesAfter": 2,
+                    "startTag": "%START_SNIPPET%",
+                    "endTag": "%END_SNIPPET%",
+                },
+                "rerankingConfig": {
+                    "rerankerId": 272725718,
+                    "mmrConfig": {
+                        "diversityBias": 0.35
+                    }
+                },
+                "corpusKey": [
+                    {
+                        "customerId": customer_id,
+                        "corpusId": corpus_id,
+                        "semantics": 0,
+                        "metadataFilter": "",
+                        "lexicalInterpolationConfig": {
+                            "lambda": 0
+                        },
+                        "dim": []
+                    }
+                ],
+                "summary": [
+                    {
+                        "maxSummarizedResults": 5,
+                        "responseLang": "auto",
+                        "summarizerPromptName": "vectara-summary-ext-v1.2.0"
+                    }
+                ]
+            }
+        ]
+    }
+
+    # Make the API request using Gradio
+    response = requests.post(
+        "https://api.vectara.io/v1/query",
+        json=request_body,  # Use json to automatically serialize the request body
+        verify=True,
+        headers=api_key_header
+    )
+
+    if response.status_code == 200:
+        query_data = response.json()
+        if query_data:
+            sources_info = []
+
+            # Extract the summary.
+            summary = query_data['responseSet'][0]['summary'][0]['text']
+
+            # Iterate over all response sets
+            for response_set in query_data.get('responseSet', []):
+                # Extract sources
+                # Limit to top 5 sources.
+                for source in response_set.get('response', [])[:5]:
+                    source_metadata = source.get('metadata', [])
+                    source_info = {}
+
+                    for metadata in source_metadata:
+                        metadata_name = metadata.get('name', '')
+                        metadata_value = metadata.get('value', '')
+
+                        if metadata_name == 'title':
+                            source_info['title'] = metadata_value
+                        elif metadata_name == 'author':
+                            source_info['author'] = metadata_value
+                        elif metadata_name == 'pageNumber':
+                            source_info['page number'] = metadata_value
+
+                    if source_info:
+                        sources_info.append(source_info)
+
+            result = {"summary": summary, "sources": sources_info}
+            return f"{json.dumps(result, indent=2)}"
+        else:
+            return "No data found in the response."
     else:
-        return "🟢", "The score is greater than 0.5"
+        return f"Error: {response.status_code}"
 
 # Create the Gradio interface
 iface = gr.Interface(