Update app.py

app.py

@@ -1,11 +1,132 @@
+# TOOLS
+
+import os
 import gradio as gr
+import logging
+from typing import Dict, List
+
 from huggingface_hub import InferenceClient
+from llama_index.core.tools import FunctionTool
+from duckduckgo_search import DDGS
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+# Load HF_TOKEN from environment
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# === Core Components ===
+class QuestionValidation:
+    def __init__(self, hf_token: str):
+        self.client = InferenceClient(provider="hf-inference", api_key=hf_token)
+        self.llm2_model = "HuggingFaceH4/zephyr-7b-beta"
+        self.embedding_model = SentenceTransformer("sentence-transformers/all-mpnet-base-v2")
+
+    def guess_question(self, answer: str) -> str:
+        prompt = f"This was the answer: {answer}\nWhat question would likely have led to it?"
+        response = self.client.text_generation(prompt=prompt, model=self.llm2_model, max_new_tokens=100)
+        return response
+
+    def compute_similarity(self, q1: str, q2: str) -> float:
+        embeddings = self.embedding_model.encode([q1, q2])
+        return cosine_similarity([embeddings[0]], [embeddings[1]])[0][0]
+
+    def validate_question_only(self, original_question: str, guessed_question: str) -> Dict[str, float]:
+        similarity = self.compute_similarity(original_question, guessed_question)
+        return {
+            "original_question": original_question,
+            "guessed_question": guessed_question,
+            "similarity": round(float(similarity), 4)
+        }
+
+def search_web(query: str, max_results: int = 5) -> List[Dict[str, str]]:
+    try:
+        with DDGS() as ddgs:
+            results = [r for r in ddgs.text(query, max_results=max_results)]
+        return results
+    except Exception as e:
+        return [{"error": str(e)}]
+
+def evaluate_math_expression(expr: str) -> str:
+    try:
+        result = eval(expr, {"__builtins__": {}})
+        return str(result)
+    except Exception as e:
+        return f"Error evaluating expression: {e}"
+
+validator = QuestionValidation(hf_token=HF_TOKEN)
+
+validate_tool = FunctionTool.from_defaults(
+    fn=validator.validate_question_only,
+    name="validate_question",
+    description="Compares the similarity between two questions."
+)
+
+search_tool = FunctionTool.from_defaults(
+    fn=search_web,
+    name="search_web",
+    description="Searches the web using DuckDuckGo and returns results."
+)
+
+math_tool = FunctionTool.from_defaults(
+    fn=evaluate_math_expression,
+    name="math_tool",
+    description="Evaluates a basic Python math expression."
+)
 
+TOOLS = [validate_tool, search_tool, math_tool]
+
+from llama_index.core.agent import ReActAgent
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+
+llm = HuggingFaceInferenceAPI(
+    model_name="mistralai/Mistral-7B-Instruct-v0.3",
+    token=HF_TOKEN,
+    context_window=3900,
+    max_new_tokens=256,
+    generate_kwargs={"temperature": 0.7}
+)
+
+agent = ReActAgent.from_tools(
+    tools=TOOLS,
+    llm=llm,
+    verbose=True,
+    max_iterations=3
+)
+
+def question_loop_agent(user_question: str):
+    llm_answer = llm.complete(user_question).text.strip()
+    similarity_score = 0.0
+    retry = 0
+    max_retries = 5
+
+    while retry < max_retries:
+        guessed_question = validator.guess_question(llm_answer)
+        similarity_score = validator.compute_similarity(user_question, guessed_question)
+        if similarity_score > 0.6:
+            break
+        retry += 1
+
+    return (
+        f"Original Question: {user_question}\n\n"
+        f"Answer: {llm_answer}\n\n"
+        f"Guessed Question: {guessed_question}\n\n"
+        f"Similarity Score: {similarity_score:.4f}"
+    )
+
+iface_loop = gr.Interface(
+    fn=question_loop_agent,
+    inputs=gr.Textbox(lines=2, placeholder="Ask me a question..."),
+    outputs="text",
+    title="🧠 Question Similarity Loop Agent",
+    description="Loops until the guessed question has a similarity score > 0.6."
+)
+
+# --- Additional ChatInterface Template ---
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
 def respond(
     message,
@@ -24,7 +145,6 @@ def respond(
             messages.append({"role": "assistant", "content": val[1]})
 
     messages.append({"role": "user", "content": message})
-
     response = ""
 
     for message in client.chat_completion(
@@ -35,30 +155,19 @@ def respond(
         top_p=top_p,
     ):
         token = message.choices[0].delta.content
-
         response += token
         yield response
 
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
 demo = gr.ChatInterface(
     respond,
     additional_inputs=[
         gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
         gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
         gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p (nucleus sampling)"),
     ],
 )
 
-
 if __name__ == "__main__":
-    demo.launch()
+    iface_loop.launch()
+    # demo.launch()  # Uncomment to run the chat template too