Update app.py

app.py

@@ -1,59 +1,148 @@
 api_key = "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"
 
-import argparse
 import streamlit as st
-from langchain.agents import create_tool_calling_agent, AgentExecutor
-from langchain_core.runnables import Runnable
-from crewai_tools import ScrapeWebsiteTool
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_community.chat_models import ChatLiteLLM
-from litellm import completion
-import importlib
-
-# Define your custom LLM wrapper class
-class CustomLLM(ChatLiteLLM):
-    def __init__(self):
-        super().__init__(model="gpt-4")
-
-    def _call(self, prompt: str, stop=None):
-        response = completion(model="gpt-4", messages=[{"role": "user", "content": prompt}])
-        return response.choices[0].message["content"]
-
-# Define your agent class
-class GaiaAgent:
-    def __init__(self):
-        self.llm = CustomLLM()
-
-        self.prompt = ChatPromptTemplate.from_messages([
-            ("system", "You are a helpful assistant."),
-            MessagesPlaceholder(variable_name="chat_history"),
-            ("human", "{input}"),
-            MessagesPlaceholder(variable_name="agent_scratchpad"),
-        ])
-
-        self.tools = [
-            ScrapeWebsiteTool()
-        ]
-
-        self.agent: Runnable = create_tool_calling_agent(self.llm, self.tools, self.prompt)
-        self.agent_executor: AgentExecutor = AgentExecutor(agent=self.agent, tools=self.tools, verbose=True)
-
-    def run(self):
-        st.title("🧠 GAIA-compatible Agent")
-        user_input = st.text_input("Enter your query")
-        if user_input:
-            response = self.agent_executor.invoke({"input": user_input})
-            st.write("Response:", response)
-
-# Main CLI-compatible entry point
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--import", type=str, required=False, help="Module to import (ignored for static agent)")
-    parser.add_argument("--class", type=str, required=False, help="Class name to instantiate (ignored for static agent)")
-    parser.add_argument("--device", type=str, default="cpu", help="Device type (not used in this agent)")
-    args = parser.parse_args()
-
-    # Directly instantiate and run the predefined GaiaAgent class
-    agent = GaiaAgent()
-    agent.run()
+from langchain_groq import ChatGroq
+from langchain_community.utilities import ArxivAPIWrapper, WikipediaAPIWrapper
+from langchain_community.tools import ArxivQueryRun, WikipediaQueryRun, DuckDuckGoSearchRun
+from langchain.agents import initialize_agent, AgentType
+from langchain.callbacks import StreamlitCallbackHandler
+import os
+import requests
+import pandas as pd
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Constants for Basic Agent Evaluation
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# Initialize search tools
+api_wrapper_arxiv = ArxivAPIWrapper(top_k_results=1, doc_content_chars_max=250)
+arxiv = ArxivQueryRun(api_wrapper=api_wrapper_arxiv)
+api_wrapper_wiki = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=250)
+wiki = WikipediaQueryRun(api_wrapper=api_wrapper_wiki)
+search = DuckDuckGoSearchRun(name="Search")
+
+# Streamlit app layout
+st.title("Langchain - Chat with Search & Evaluation")
+
+# Sidebar for settings
+st.sidebar.title("Settings")
+api_key = st.sidebar.text_input("Enter your Groq API Key:", type="password")
+
+# Initialize chat messages
+if "messages" not in st.session_state:
+    st.session_state["messages"] = [
+        {"role": "assistant", "content": "Hi, I am a Chatbot who can search the web and evaluate questions. How can I help you?"}
+    ]
+
+# Display chat messages
+for msg in st.session_state.messages:
+    st.chat_message(msg["role"]).write(msg["content"])
+
+# Chat input
+if prompt := st.chat_input(placeholder="What is machine learning?"):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    st.chat_message("user").write(prompt)
+
+    if not api_key:
+        st.error("Please enter your Groq API key in the sidebar.")
+        st.stop()
+
+    llm = ChatGroq(groq_api_key=api_key, model_name="Llama3-8b-8192", streaming=True)
+    tools = [search, arxiv, wiki]
+
+    search_agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, handle_parsing_errors=True)
+
+    with st.chat_message("assistant"):
+        st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
+        response = search_agent.run(st.session_state.messages, callbacks=[st_cb])
+        st.session_state.messages.append({'role': 'assistant', "content": response})
+        st.write(response)
+
+# Basic Agent Evaluation Section
+st.sidebar.title("Basic Agent Evaluation")
+
+def run_evaluation():
+    """Function to run the evaluation using the current Groq-powered agent"""
+    if not api_key:
+        st.error("Please enter your Groq API key in the sidebar.")
+        return "API key required", pd.DataFrame()
+
+    username = "streamlit_user"  # Default username for Streamlit
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+    space_id = os.getenv("SPACE_ID", "local")
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id != "local" else "local_execution"
+
+    # 1. Instantiate Agent
+    try:
+        llm = ChatGroq(groq_api_key=api_key, model_name="Llama3-8b-8192")
+        tools = [search, arxiv, wiki]
+        agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, handle_parsing_errors=True)
+    except Exception as e:
+        return f"Error initializing agent: {e}", pd.DataFrame()
+
+    # 2. Fetch Questions
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+            return "Fetched questions list is empty or invalid format.", pd.DataFrame()
+    except Exception as e:
+        return f"Error fetching questions: {e}", pd.DataFrame()
+
+    # 3. Run Agent
+    results_log = []
+    answers_payload = []
+    for item in questions_data:
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            continue
+        try:
+            submitted_answer = agent.run(question_text)
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+        except Exception as e:
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+
+    if not answers_payload:
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare and Submit
+    submission_data = {
+        "username": username,
+        "agent_code": agent_code,
+        "answers": answers_payload
+    }
+
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        return final_status, pd.DataFrame(results_log)
+    except Exception as e:
+        return f"Submission Failed: {e}", pd.DataFrame(results_log)
+
+# Evaluation button in sidebar
+if st.sidebar.button("Run Evaluation & Submit Answers"):
+    with st.spinner("Running evaluation and submitting answers..."):
+        status, results = run_evaluation()
+        
+    st.sidebar.text_area("Evaluation Status", value=status, height=150)
+    
+    if not results.empty:
+        st.subheader("Evaluation Results")
+        st.dataframe(results)