Upload 2 files

agent.py

@@ -0,0 +1,298 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# --- Supabase Setup (only if credentials are provided) ---
+supabase_url = os.getenv("SUPABASE_URL")
+supabase_key = os.getenv("SUPABASE_SERVICE_KEY") or os.getenv("SUPABASE_KEY")
+
+if supabase_url and supabase_key:
+    from supabase.client import Client, create_client
+    from langchain_community.vectorstores import SupabaseVectorStore
+    from langchain.tools.retriever import create_retriever_tool
+    from langchain_openai import OpenAIEmbeddings
+    supabase: Client = create_client(supabase_url, supabase_key)
+else:
+    supabase = None
+
+# --- Standard Imports ---
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import tools_condition, ToolNode
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+from langchain_core.tools import tool
+
+# OpenAI LLM
+from langchain_openai import ChatOpenAI
+
+# Optional document loaders
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
+
+# --- Simple Math Tools ---
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply two integers and return the result"""
+    return a * b
+
+@tool
+def add(a: int, b: int) -> int:
+    """Add two integers and return the sum"""
+    return a + b
+
+@tool
+def subtract(a: int, b: int) -> int:
+    """Subtract the second integer from the first and return the difference"""
+    return a - b
+
+@tool
+def divide(a: int, b: int) -> float:
+    """Divide the first integer by the second and return the quotient"""
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """Return the modulus of dividing the first integer by the second"""
+    return a % b
+
+# --- Search Tools ---
+@tool
+def wiki_search(query: str) -> str:
+    """Search Wikipedia for the query and return up to 2 documents"""
+    try:
+        docs = WikipediaLoader(query=query, load_max_docs=2).load()
+        return "\n\n---\n\n".join(
+            f'<Document source="{doc.metadata["source"]}"/>\n{doc.page_content}' for doc in docs
+        )
+    except Exception as e:
+        return f"Wikipedia search failed: {str(e)}"
+
+@tool
+def web_search(query: str) -> str:
+    """Search the web using Tavily and return up to 3 results"""
+    try:
+        tavily_api_key = os.getenv("TAVILY_API_KEY")
+        if not tavily_api_key:
+            return "Web search unavailable: TAVILY_API_KEY not configured"
+        
+        search_tool = TavilySearchResults(max_results=3, api_key=tavily_api_key)
+        docs = search_tool.invoke({"query": query})
+        return "\n\n---\n\n".join(
+            f'<Document source="{doc.get("url", "Unknown")}"/>\n{doc.get("content", "")}' for doc in docs
+        )
+    except Exception as e:
+        return f"Web search failed: {str(e)}"
+
+@tool
+def arxiv_search(query: str) -> str:
+    """Search Arxiv for the query and return up to 3 documents"""
+    try:
+        docs = ArxivLoader(query=query, load_max_docs=3).load()
+        return "\n\n---\n\n".join(
+            f'<Document source="{doc.metadata["source"]}"/>\n{doc.page_content[:1000]}' for doc in docs
+        )
+    except Exception as e:
+        return f"Arxiv search failed: {str(e)}"
+
+# --- Assemble Tools List ---
+tools = [multiply, add, subtract, divide, modulus, wiki_search, web_search, arxiv_search]
+
+# If supabase is configured, add retriever tool
+if supabase:
+    try:
+        embeddings = OpenAIEmbeddings()
+        vector_store = SupabaseVectorStore(
+            client=supabase,
+            embedding=embeddings,
+            table_name="documents",
+            query_name="match_documents_langchain",
+        )
+        retriever_tool = create_retriever_tool(
+            retriever=vector_store.as_retriever(),
+            name="Question Search",
+            description="Retrieve similar questions from the vector store",
+        )
+        tools.append(retriever_tool)
+    except Exception as e:
+        print(f"Could not initialize Supabase retriever: {e}")
+
+# --- Load System Prompt ---
+def load_system_prompt():
+    """Load system prompt with fallback"""
+    try:
+        with open("system_prompt.txt", "r", encoding="utf-8") as f:
+            return SystemMessage(content=f.read())
+    except FileNotFoundError:
+        # Fallback system prompt
+        default_prompt = """You are a helpful AI assistant with access to various tools including:
+- Math operations (add, subtract, multiply, divide, modulus)
+- Search capabilities (Wikipedia, Arxiv, web search via Tavily)
+- Information retrieval
+
+Use these tools when appropriate to answer questions accurately and helpfully. When performing calculations, always use the provided math tools. When users ask for information that might require current data or research, use the appropriate search tools.
+
+Be concise but thorough in your responses. If you use a tool, explain what you found or calculated."""
+        return SystemMessage(content=default_prompt)
+
+sys_msg = load_system_prompt()
+
+# --- Graph Builder (OpenAI) ---
+def build_graph():
+    """
+    Build and return a StateGraph using OpenAI ChatGPT with tools.
+    """
+    print("=== BUILDING OPENAI GRAPH ===")
+    
+    # Check for OpenAI API key
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    print(f"OpenAI API Key: {'Found' if openai_api_key else 'Not found'}")
+    
+    if openai_api_key:
+        print(f"API Key starts with: {openai_api_key[:10]}...")
+    
+    try:
+        if openai_api_key and len(openai_api_key.strip()) > 0:
+            print("Attempting to initialize OpenAI ChatGPT...")
+            
+            # Initialize OpenAI LLM
+            llm = ChatOpenAI(
+                model="gpt-3.5-turbo",  # You can change to "gpt-4" if you have access
+                temperature=0.1,
+                api_key=openai_api_key.strip(),
+                max_tokens=512
+            )
+            
+            # Test the connection
+            test_response = llm.invoke([HumanMessage(content="Hello")])
+            print("✓ Successfully connected to OpenAI")
+            print(f"Test response: {test_response.content[:50]}...")
+            
+        else:
+            raise Exception("No valid OPENAI_API_KEY found")
+        
+    except Exception as e:
+        print(f"Error initializing OpenAI LLM: {e}")
+        print("Creating functional mock LLM...")
+        
+        class FunctionalMockLLM:
+            def bind_tools(self, tools):
+                self.tools = tools
+                return self
+                
+            def invoke(self, messages):
+                from langchain_core.messages import AIMessage
+                import json
+                import re
+                
+                last_msg = messages[-1] if messages else None
+                if not last_msg:
+                    return AIMessage(content="Please ask me a question!")
+                
+                content = getattr(last_msg, 'content', str(last_msg))
+                content_lower = content.lower()
+                
+                # Handle math operations with tool calls
+                math_patterns = [
+                    (r'(\d+)\s*\+\s*(\d+)', 'add'),
+                    (r'(\d+)\s*-\s*(\d+)', 'subtract'),
+                    (r'(\d+)\s*\*\s*(\d+)', 'multiply'),
+                    (r'(\d+)\s*/\s*(\d+)', 'divide'),
+                    (r'(\d+)\s*%\s*(\d+)', 'modulus'),
+                ]
+                
+                for pattern, operation in math_patterns:
+                    match = re.search(pattern, content)
+                    if match:
+                        a, b = int(match.group(1)), int(match.group(2))
+                        
+                        tool_call = {
+                            "name": operation,
+                            "args": {"a": a, "b": b},
+                            "id": f"call_{operation}_{a}_{b}"
+                        }
+                        
+                        return AIMessage(
+                            content=f"I'll {operation} {a} and {b} for you.",
+                            tool_calls=[tool_call]
+                        )
+                
+                # Handle search requests
+                if any(word in content_lower for word in ['search', 'find', 'look up', 'what is', 'who is', 'tell me about']):
+                    # Extract search query
+                    search_query = content
+                    for phrase in ['search for', 'find', 'look up', 'what is', 'who is', 'tell me about']:
+                        search_query = search_query.lower().replace(phrase, '').strip()
+                    
+                    if len(search_query) > 100:
+                        search_query = search_query[:100]
+                    
+                    if 'wikipedia' in content_lower:
+                        tool_name = "wiki_search"
+                    elif 'arxiv' in content_lower or 'research' in content_lower or 'paper' in content_lower:
+                        tool_name = "arxiv_search"
+                    else:
+                        tool_name = "web_search"
+                    
+                    tool_call = {
+                        "name": tool_name,
+                        "args": {"query": search_query},
+                        "id": f"call_{tool_name}_{hash(search_query) % 1000}"
+                    }
+                    
+                    return AIMessage(
+                        content=f"I'll search for information about: {search_query}",
+                        tool_calls=[tool_call]
+                    )
+                
+                # Default response for other questions
+                return AIMessage(content=f"I understand you're asking: {content[:200]}... I can help with math calculations and information searches. Please configure OPENAI_API_KEY for full functionality, or try asking me to calculate something or search for information.")
+        
+        llm = FunctionalMockLLM()
+        print("��� Using functional mock LLM")
+    
+    # Bind tools to LLM
+    llm_with_tools = llm.bind_tools(tools)
+
+    def retriever(state: MessagesState):
+        """Add system message and handle retrieval if Supabase is available"""
+        messages = [sys_msg] + state["messages"]
+        
+        if supabase and len(tools) > 8:  # Check if retriever tool was added
+            try:
+                query = state["messages"][-1].content
+                docs = vector_store.similarity_search(query, k=1)
+                if docs:
+                    doc = docs[0]
+                    content = doc.page_content
+                    answer = content.split("Final answer :")[-1].strip() if "Final answer :" in content else content.strip()
+                    return {"messages": messages + [AIMessage(content=f"Retrieved context: {answer}")]}
+            except Exception as e:
+                print(f"Retrieval error: {e}")
+        
+        return {"messages": messages}
+
+    def assistant(state: MessagesState):
+        """Main assistant function"""
+        try:
+            response = llm_with_tools.invoke(state["messages"])
+            return {"messages": [response]}
+        except Exception as e:
+            print(f"Assistant error: {e}")
+            return {"messages": [AIMessage(content=f"I encountered an error: {str(e)}. Please make sure your OPENAI_API_KEY is configured correctly.")]}
+
+    # Build the graph
+    g = StateGraph(MessagesState)
+    g.add_node("retriever", retriever)
+    g.add_node("assistant", assistant)
+    g.add_node("tools", ToolNode(tools))
+    
+    # Define edges
+    g.add_edge(START, "retriever")
+    g.add_edge("retriever", "assistant")
+    g.add_conditional_edges("assistant", tools_condition)
+    g.add_edge("tools", "assistant")
+    
+    print("✓ Graph compiled successfully")
+    return g.compile()

app.py

@@ -0,0 +1,217 @@
+import os
+import gradio as gr
+import requests
+import pandas as pd
+from langchain_core.messages import HumanMessage
+from agent import build_graph
+
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+class BasicAgent:
+    """A langgraph agent using OpenAI."""
+    def __init__(self):
+        print("=== INITIALIZING OPENAI BASIC AGENT ===")
+        print(f"Current working directory: {os.getcwd()}")
+        print(f"Files in directory: {os.listdir('.')}")
+        
+        # Check environment variables
+        print("=== ENVIRONMENT VARIABLES ===")
+        for key in sorted(os.environ.keys()):
+            if any(term in key.upper() for term in ['OPENAI', 'API_KEY', 'TOKEN', 'TAVILY']):
+                value = os.environ[key]
+                print(f"{key}: {value[:10] if value else 'None'}...")
+        
+        # Check specifically for OpenAI API key
+        openai_key = os.getenv("OPENAI_API_KEY")
+        if openai_key:
+            print(f"✓ OpenAI API Key found: {openai_key[:15]}...")
+        else:
+            print("✗ OpenAI API Key not found!")
+            print("Please add OPENAI_API_KEY to your Hugging Face Space secrets")
+        
+        try:
+            self.graph = build_graph()
+            print("✓ Graph built successfully")
+        except Exception as e:
+            print(f"✗ Error building graph: {e}")
+            raise e
+
+    def __call__(self, question: str) -> str:
+        print(f"=== AGENT CALL ===")
+        print(f"Question: {question[:100]}...")
+        
+        try:
+            messages = [HumanMessage(content=question)]
+            print(f"Invoking graph with messages: {len(messages)}")
+            
+            result = self.graph.invoke({"messages": messages})
+            print(f"Graph result keys: {result.keys() if isinstance(result, dict) else 'Not a dict'}")
+            
+            if 'messages' in result and result['messages']:
+                answer = result['messages'][-1].content
+                print(f"Answer (first 100 chars): {answer[:100]}...")
+                return answer
+            else:
+                print("No messages in result")
+                return "I apologize, but I couldn't generate a response."
+                
+        except Exception as e:
+            print(f"Error in agent call: {e}")
+            return f"Error: {str(e)}"
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    print("=== STARTING RUN AND SUBMIT ===")
+    space_id = os.getenv("SPACE_ID")
+    print(f"Space ID: {space_id}")
+    
+    if not profile:
+        return "Please Login to Hugging Face with the button.", None
+    
+    username = profile.username
+    print(f"Username: {username}")
+    
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+    
+    print("=== INITIALIZING AGENT ===")
+    try:
+        agent = BasicAgent()
+        print("✓ Agent initialized successfully")
+    except Exception as e:
+        error_msg = f"Error initializing agent: {e}"
+        print(error_msg)
+        return error_msg, None
+
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(f"Agent code URL: {agent_code}")
+
+    print("=== FETCHING QUESTIONS ===")
+    try:
+        resp_q = requests.get(questions_url, timeout=15)
+        resp_q.raise_for_status()
+        questions = resp_q.json()
+        print(f"✓ Fetched {len(questions)} questions")
+    except Exception as e:
+        error_msg = f"Error fetching questions: {e}"
+        print(error_msg)
+        return error_msg, None
+
+    results_log = []
+    answers = []
+    
+    print("=== PROCESSING QUESTIONS ===")
+    for i, item in enumerate(questions):
+        task_id = item.get("task_id")
+        q = item.get("question")
+        
+        print(f"\n--- Question {i+1}/{len(questions)} ---")
+        print(f"Task ID: {task_id}")
+        print(f"Question: {q[:100]}...")
+        
+        if not task_id or q is None:
+            print("Skipping - missing task_id or question")
+            continue
+            
+        try:
+            print("Calling agent...")
+            ans = agent(q)
+            print(f"Answer: {ans[:100]}...")
+            
+            answers.append({"task_id": task_id, "submitted_answer": ans})
+            results_log.append({"Task ID": task_id, "Question": q, "Submitted Answer": ans})
+            print("✓ Question processed successfully")
+            
+        except Exception as e:
+            error_msg = f"ERROR: {e}"
+            print(f"✗ Error processing question: {error_msg}")
+            results_log.append({"Task ID": task_id, "Question": q, "Submitted Answer": error_msg})
+
+    if not answers:
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    print(f"=== SUBMITTING {len(answers)} ANSWERS ===")
+    payload = {"username": username.strip(), "agent_code": agent_code, "answers": answers}
+    
+    try:
+        resp_s = requests.post(submit_url, json=payload, timeout=60)
+        resp_s.raise_for_status()
+        data = resp_s.json()
+        
+        status = (
+            f"Submission Successful!\n"
+            f"User: {data.get('username')}\n"
+            f"Score: {data.get('score', 'N/A')}% "
+            f"({data.get('correct_count', '?')}/{data.get('total_attempted', '?')})\n"
+            f"{data.get('message', '')}"
+        )
+        print("✓ Submission successful")
+        print(status)
+        return status, pd.DataFrame(results_log)
+        
+    except Exception as e:
+        error_msg = f"Submission Failed: {e}"
+        print(error_msg)
+        return error_msg, pd.DataFrame(results_log)
+
+# Simple test function for debugging
+def test_agent():
+    """Test function to verify agent works"""
+    print("=== TESTING AGENT ===")
+    try:
+        agent = BasicAgent()
+        test_questions = [
+            "What is 2 + 3?",
+            "What is 10 * 5?",
+            "Search for information about Python programming"
+        ]
+        
+        for q in test_questions:
+            print(f"\nTesting: {q}")
+            answer = agent(q)
+            print(f"Answer: {answer}")
+            
+    except Exception as e:
+        print(f"Test failed: {e}")
+
+with gr.Blocks() as demo:
+    gr.Markdown("# OpenAI-Powered Agent Evaluation Runner")
+    gr.Markdown("""
+    This agent uses OpenAI's GPT models instead of Hugging Face.
+    
+    ## Setup Instructions:
+    1. Get an OpenAI API key from https://platform.openai.com/api-keys
+    2. Add it as `OPENAI_API_KEY` in your Hugging Face Space secrets
+    3. (Optional) Add `TAVILY_API_KEY` for web search functionality
+    4. Log in with the button below
+    5. Click **Run Evaluation & Submit All Answers**
+    
+    ## Current Configuration:
+    - Model: GPT-3.5-turbo (change to GPT-4 in agent.py if you have access)
+    - Tools: Math operations, Wikipedia search, Arxiv search, Web search (if Tavily configured)
+    """)
+    
+    with gr.Row():
+        gr.LoginButton()
+        test_btn = gr.Button("Test Agent", variant="secondary")
+    
+    run_btn = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
+    status_out = gr.Textbox(label="Run Status / Submission Result", lines=5)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    
+    # Button actions
+    run_btn.click(fn=run_and_submit_all, outputs=[status_out, results_table])
+    test_btn.click(fn=test_agent, outputs=[])
+
+if __name__ == "__main__":
+    print("=== STARTING OPENAI GRADIO APP ===")
+    
+    # Quick environment check
+    openai_key = os.getenv("OPENAI_API_KEY")
+    if openai_key:
+        print(f"✓ OpenAI API Key configured: {openai_key[:15]}...")
+    else:
+        print("⚠️  OpenAI API Key not found - please add OPENAI_API_KEY to your Space secrets")
+    
+    demo.launch(debug=True, share=False)