+ files fetching for the agent

langraph_agent.py

@@ -15,6 +15,7 @@ from langchain_core.messages import SystemMessage, HumanMessage
 from langchain_core.tools import tool
 from langchain.tools.retriever import create_retriever_tool
 from supabase.client import Client, create_client
+import requests  # NEW: for HTTP requests to scoring API
 
 from langfuse.langchain import CallbackHandler
 
@@ -32,6 +33,9 @@ load_dotenv("env.local")  # Try env.local as backup
 print(f"SUPABASE_URL loaded: {bool(os.environ.get('SUPABASE_URL'))}")
 print(f"GROQ_API_KEY loaded: {bool(os.environ.get('GROQ_API_KEY'))}")
 
+# Base URL of the scoring API (duplicated here to avoid circular import with basic_agent)
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
 @tool
 def multiply(a: int, b: int) -> int:
     """Multiply two numbers.
@@ -240,21 +244,67 @@ def build_graph(provider: str = "groq"):
             if not state["messages"]:
                 print("Retriever node: No messages in state")
                 return {"messages": [sys_msg]}
+
+            # Extract the user query content early for downstream steps
+            query_content = state["messages"][0].content
+
+            # ------------------- NEW: fetch attachment if available -------------------
+            attachment_msg = None
+            try:
+                resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=30)
+                resp.raise_for_status()
+                questions = resp.json()
+                matched_task_id = None
+                for q in questions:
+                    if str(q.get("question")).strip() == str(query_content).strip():
+                        matched_task_id = str(q.get("task_id"))
+                        break
+                if matched_task_id:
+                    print(f"Retriever node: Found task_id {matched_task_id} for current question, attempting to download attachment…")
+                    file_resp = requests.get(f"{DEFAULT_API_URL}/files/{matched_task_id}", timeout=60)
+                    if file_resp.status_code == 200 and file_resp.content:
+                        try:
+                            file_text = file_resp.content.decode("utf-8", errors="replace")
+                        except Exception:
+                            file_text = "(binary or non-UTF8 file omitted)"
+                        MAX_CHARS = 8000
+                        if len(file_text) > MAX_CHARS:
+                            print(f"Retriever node: Attachment length {len(file_text)} > {MAX_CHARS}, truncating…")
+                            file_text = file_text[:MAX_CHARS] + "\n… (truncated)"
+                        attachment_msg = HumanMessage(content=f"Attached file content for task {matched_task_id}:\n```python\n{file_text}\n```")
+                        print("Retriever node: Prepared attachment message")
+                    else:
+                        print(f"Retriever node: No attachment found for task {matched_task_id} (status {file_resp.status_code})")
+            except Exception as api_e:
+                print(f"Retriever node: Error while fetching attachment – {api_e}")
+            # -------------------------------------------------------------------------
+
+            # If vector store unavailable, simply return sys_msg + user message (+ attachment if any)
             if not vector_store:
+                msgs = [sys_msg] + state["messages"]
+                if attachment_msg:
+                    msgs.append(attachment_msg)
                 print("Retriever node: Vector store not available, skipping retrieval")
-                return {"messages": [sys_msg] + state["messages"]}
-            query_content = state["messages"][0].content
-            print(f"Retriever node: Searching for similar questions with query: {query_content[:100]}...")
+                return {"messages": msgs}
+
+            # Perform similarity search when vector store is available
+            print(f"Retriever node: Searching for similar questions with query: {query_content[:100]}…")
             similar_question = vector_store.similarity_search(query_content)
             print(f"Retriever node: Found {len(similar_question)} similar questions")
-            if not similar_question:
+            msgs = [sys_msg] + state["messages"]
+            if similar_question:
+                example_msg = HumanMessage(content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}")
+                msgs.append(example_msg)
+                print("Retriever node: Added example message from similar question")
+            else:
                 print("Retriever node: No similar questions found, proceeding without example")
-                return {"messages": [sys_msg] + state["messages"]}
-            example_msg = HumanMessage(
-                content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
-            )
-            print(f"Retriever node: Added example message from similar question")
-            return {"messages": [sys_msg] + state["messages"] + [example_msg]}
+
+            # Attach the file content if we have it
+            if attachment_msg:
+                msgs.append(attachment_msg)
+                print("Retriever node: Added attachment content to messages")
+
+            return {"messages": msgs}
         except Exception as e:
             print(f"Error in retriever node: {e}")
             return {"messages": [sys_msg] + state["messages"]}

quick_specific_agent_test.py

@@ -0,0 +1,91 @@
+import os
+import sys
+import tempfile
+import requests
+from basic_agent import BasicAgent, DEFAULT_API_URL
+from langchain_core.messages import HumanMessage
+from langfuse.langchain import CallbackHandler
+
+# Initialize Langfuse CallbackHandler for LangGraph/Langchain (tracing)
+try:
+    langfuse_handler = CallbackHandler()
+except Exception as e:
+    print(f"Warning: Could not initialize Langfuse handler: {e}")
+    langfuse_handler = None
+
+# Default Task ID (replace with your desired one or pass via CLI)
+DEFAULT_TASK_ID = "f918266a-b3e0-4914-865d-4faa564f1aef"
+
+def fetch_question_by_id(task_id: str, api_base: str = DEFAULT_API_URL):
+    """Return JSON of a question for a given task_id.
+
+    The scoring API does not (yet) expose an explicit /question/{id} endpoint,
+    so we fetch the full /questions list and filter locally. This works fine
+    because the list is small (<100 items).
+    """
+    try:
+        resp = requests.get(f"{api_base}/questions", timeout=30)
+        resp.raise_for_status()
+        questions = resp.json()
+    except Exception as e:
+        raise RuntimeError(f"Failed to fetch questions list: {e}") from e
+
+    for q in questions:
+        if str(q.get("task_id")) == str(task_id):
+            return q
+
+    raise ValueError(f"Task ID {task_id} not found in /questions list.")
+
+
+def maybe_download_file(task_id: str, api_base: str = DEFAULT_API_URL) -> str | None:
+    """Try to download the file associated with a given task id. Returns local path or None."""
+    url = f"{api_base}/files/{task_id}"
+    try:
+        resp = requests.get(url, timeout=60)
+        if resp.status_code != 200:
+            print(f"No file associated with task {task_id} (status {resp.status_code}).")
+            return None
+        # Create temp file with same name from headers if available
+        filename = resp.headers.get("content-disposition", "").split("filename=")[-1].strip("\"") or f"{task_id}_attachment"
+        tmp_path = os.path.join(tempfile.gettempdir(), filename)
+        with open(tmp_path, "wb") as f:
+            f.write(resp.content)
+        print(f"Downloaded attachment to {tmp_path}")
+        return tmp_path
+    except requests.HTTPError as e:
+        print(f"Could not download file for task {task_id}: {e}")
+    except Exception as e:
+        print(f"Error downloading file: {e}")
+    return None
+
+
+def main():
+    # Determine the task ID (CLI arg > env var > default)
+    task_id = (
+        sys.argv[1] if len(sys.argv) > 1 else os.environ.get("TASK_ID", DEFAULT_TASK_ID)
+    )
+    print(f"Using task ID: {task_id}")
+
+    q = fetch_question_by_id(task_id)
+    question_text = q["question"]
+
+    print("\n=== Specific Question ===")
+    print(f"Task ID : {task_id}")
+    print(f"Question: {question_text}")
+
+    # Attempt to get attachment if any
+    maybe_download_file(task_id)
+
+    # Run the agent
+    agent = BasicAgent()
+    result = agent.agent.invoke({"messages": [HumanMessage(content=question_text)]}, config={"callbacks": [langfuse_handler]})
+    if isinstance(result, dict) and "messages" in result and result["messages"]:
+        answer = result["messages"][-1].content.strip()
+    else:
+        answer = str(result)
+    print("\n=== Agent Answer ===")
+    print(answer)
+
+
+if __name__ == "__main__":
+    main()