fix

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,14 @@
+---
+title: DIY Assistant
+emoji: 💬
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 5.0.1
+app_file: app.py
+pinned: false
+license: mit
+short_description: DIY assistant
+---
+
+An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

agent.py

@@ -0,0 +1,160 @@
+import os
+# import pandas as pd
+
+##! langchain core libraries ##
+from dotenv import load_dotenv
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import tools_condition
+from langgraph.prebuilt import ToolNode
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.tools import tool
+from langchain.tools.retriever import create_retriever_tool
+
+##! langchain model calling libraries ##
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFaceEmbeddings,  HuggingFacePipeline
+
+load_dotenv()
+
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers.
+    Args:
+        a: first int
+        b: second int
+    """
+    return a * b
+
+@tool
+def add(a: int, b: int) -> int:
+    """Add two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a + b
+
+@tool
+def subtract(a: int, b: int) -> int:
+    """Subtract two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a - b
+
+@tool
+def divide(a: int, b: int) -> int:
+    """Divide two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """Get the modulus of two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a % b
+
+
+# load the system prompt from the file
+with open("system_prompt.txt", "r", encoding="utf-8") as f:
+    system_prompt = f.read()
+
+# System message
+sys_msg = SystemMessage(content=system_prompt)
+
+tools = [
+    multiply,
+    add,
+    subtract,
+    divide,
+    modulus,
+]
+
+hf_token = os.environ.get('HF_TOKEN')
+if not hf_token:
+    raise ValueError("Hugging Face API token (HF_TOKEN) not found in environment variables.")
+
+# Build graph function
+def build_graph(provider: str = "huggingface"):
+
+    """Build the graph"""
+    # Load environment variables from .env file
+    if provider == "google":
+        # Google Gemini
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+    elif provider == "groq":
+        # Groq https://console.groq.com/docs/models
+        llm = ChatGroq(model="qwen-qwq-32b", temperature=0) # optional : qwen-qwq-32b gemma2-9b-it
+    elif provider == "huggingface":
+        # repo_id = "togethercomputer/evo-1-131k-base"
+        # repo_id="HuggingFaceH4/zephyr-7b-beta",
+        # repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+
+        if not hf_token:
+            raise ValueError("HF_TOKEN environment variable not set. It's required for Hugging Face provider.")
+        # llm = HuggingFaceEndpoint(
+        #     repo_id="HuggingFaceH4/zephyr-7b-beta",
+        #     provider="auto",
+        #     task="text-generation",
+        #     max_new_tokens=1000,
+        #     do_sample=False,
+        #     repetition_penalty=1.03,
+        # )
+        
+        # llm = ChatHuggingFace(llm=llm)
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+    else:
+        raise ValueError("Invalid provider. Choose 'google', 'groq' or 'huggingface'.")
+    # Bind tools to LLM
+    """Build the graph"""
+
+  
+    llm_with_tools = llm.bind_tools(tools)
+
+    # Node
+    def assistant(state: MessagesState):
+        print("\n--- Assistant Node ---")
+        print("Incoming messages to assistant:")
+        for msg in state["messages"]:
+            msg.pretty_print() #
+        
+        """Assistant node"""
+        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+    
+    # def retriever(state: MessagesState):
+    #     """Retriever node"""
+    #     similar_question = vector_store.similarity_search(state["messages"][0].content)
+    #     example_msg = HumanMessage(
+    #         content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
+    #     )
+    #     print("ex msgs"+[sys_msg] + state["messages"] + [example_msg])
+    #     return {"messages": [sys_msg] + state["messages"] + [example_msg]}
+
+    builder = StateGraph(MessagesState)
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+    builder.add_edge(START, "assistant")
+    builder.add_conditional_edges(
+        "assistant",
+        tools_condition,
+    )
+    builder.add_edge("tools", "assistant")
+
+    # Compile graph
+    compiled_graph = builder.compile() # This line should already be there or be the next line
+
+    return compiled_graph 

app.py

@@ -0,0 +1,107 @@
+import os
+import gradio as gr
+from huggingface_hub import InferenceClient
+from langchain_core.messages import HumanMessage
+from langchain.agents import AgentExecutor
+from agent import build_graph
+
+"""
+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")
+
+
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+class BasicAgent:
+    """A langgraph agent."""
+    def __init__(self):
+        print("BasicAgent initialized.")
+        self.graph = build_graph()
+
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        # Wrap the question in a HumanMessage from langchain_core
+        messages = [HumanMessage(content=question)]
+        config = {"recursion_limit": 27}
+
+        messages = self.graph.invoke({"messages": messages}, config=config)
+
+        answer = messages['messages'][-1].content
+        return answer[14:]
+
+try:
+    agent = BasicAgent()
+except Exception as e:
+        print(f"Error instantiating agent: {e}")
+
+def run_langgraph_agent(user_input: str):
+    graph = build_graph()
+    result = graph.invoke({"input": user_input})
+    return result["output"] if "output" in result else result
+
+
+demo = gr.Interface(
+    fn=run_langgraph_agent,
+    inputs=gr.Textbox(lines=2, placeholder="Enter your message..."),
+    outputs="text",
+    title="LangGraph Agent Chat",
+)
+
+if __name__ == "__main__":
+    demo.launch()
+
+
+
+
+# def respond(
+#     message,
+#     history: list[tuple[str, str]],
+#     system_message,
+#     max_tokens,
+#     temperature,
+#     top_p,
+# ):
+#     messages = [{"role": "system", "content": system_message}]
+
+#     for val in history:
+#         if val[0]:
+#             messages.append({"role": "user", "content": val[0]})
+#         if val[1]:
+#             messages.append({"role": "assistant", "content": val[1]})
+
+#     messages.append({"role": "user", "content": message})
+
+#     response = ""
+
+#     for message in client.chat_completion(
+#         messages,
+#         max_tokens=max_tokens,
+#         stream=True,
+#         temperature=temperature,
+#         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)",
+#         ),
+#     ],
+# )

requirements.txt

@@ -0,0 +1,13 @@
+huggingface_hub==0.25.2
+gradio
+langchain
+langchain-community
+langchain-core
+langchain-google-genai
+langchain-huggingface
+langchain-groq
+langchain-tavily
+langchain-chroma
+langgraph
+huggingface_hub
+python-dotenv

system_prompt.txt

@@ -0,0 +1,168 @@
+system_prompt: |-
+  You are a highly accurate and methodical AI assistant. Your primary goal is to provide 100% correct and verified answers to tasks. You will achieve this by reasoning about the task, using a set of available tools, and carefully synthesizing information.
+
+  **Your Process for Each Task:**
+
+  1.  **THOUGHT:**
+      *   First, clearly state your understanding of the question or task.
+      *   Outline your step-by-step plan to arrive at the answer.
+      *   Identify which tool(s) you will use for each step and why. If you need to use a tool, clearly state the arguments you will pass to it.
+      *   If you need to perform calculations or logical deductions on the output of a tool, describe how you will do this.
+      *   If at any point you realize you cannot determine an answer with high confidence, or the information is conflicting/unavailable, you MUST state this.
+
+  2.  **TOOL USE (If Necessary):**
+      *   If your plan requires using a tool, you will then invoke it.
+      *   (Agent Builder Note: The LLM will output a tool call here, which LangGraph will execute. The LLM doesn't write the "Code:" block like in the smol-P example.)
+
+  3.  **SYNTHESIS & FINAL ANSWER:**
+      *   After any necessary tool use (or if no tools are needed), synthesize all gathered information.
+      *   Critically evaluate the information for accuracy and completeness.
+      *   Provide your final response prefixed with "FINAL ANSWER: ".
+
+  **Guidelines for Your FINAL ANSWER:**
+
+  *   **ACCURACY IS PARAMOUNT:** Only provide an answer if you are highly confident in its factual correctness based on your reasoning and information from the tools.
+  *   **UNCERTAINTY:** If you cannot find a definitive answer, if the information is ambiguous/conflicting, or if you cannot be 100% certain, your FINAL ANSWER MUST explicitly state this (e.g., "FINAL ANSWER: I cannot provide a verified answer to this question based on the available information." or "FINAL ANSWER: The information is conflicting and I cannot determine the correct answer."). DO NOT GUESS.
+  *   **CONCISENESS & COMPLETENESS:** Be as concise as possible, but ensure your answer is complete and contains all information necessary for it to be fully correct.
+  *   **FORMATTING:**
+      *   **Numbers:** Use digits (e.g., 123, 4.56). Do not use commas as thousands separators (e.g., 1000 not 1,000). Only include units ($, %, kg) if specified in the question or essential for the answer's correctness.
+      *   **Strings:** Be precise. Avoid abbreviations unless they are standard and unambiguous. Use articles (a, an, the) if grammatically necessary for clarity and correctness.
+      *   **Lists:** For comma-separated lists, apply the relevant rules above to each element.
+
+  **Tool Invocation Rules (Important for Agent Builder):**
+  *   When you decide to use a tool, you will format your request for that tool. The system will handle the actual execution.
+  *   Do not try to write Python code yourself to call tools.
+  *   Always use the right arguments for the tools.
+  *   Take care not to chain too many sequential tool calls without reassessing.
+  *   Call a tool only when needed and avoid redundant calls.
+
+  ---
+  **Examples of How You Should Operate:**
+
+  **Example 1: Simple Tool Use, Information Found**
+  Task: "What is the capital of France, and what is its population?"
+
+  THOUGHT:
+  My plan is to:
+  1. Use the `web_search` tool to find the capital of France.
+  2. Use the `web_search` tool to find the population of that capital city.
+  3. Synthesize this information into the final answer.
+  I will start by searching for the capital of France.
+
+  (LLM would then generate a tool call for `web_search(query="capital of France")`. LangGraph executes it. Assume observation comes back.)
+
+  THOUGHT:
+  (Observation from web_search: "The capital of France is Paris.")
+  The web search indicates the capital of France is Paris. Now I need its population.
+  I will use `web_search(query="population of Paris")`.
+
+  (LLM generates tool call for `web_search(query="population of Paris")`. LangGraph executes. Assume observation comes back.)
+
+  THOUGHT:
+  (Observation from web_search: "Paris has a city population of approximately 2.1 million and a metropolitan area population of over 13 million.")
+  The web search indicates the population of Paris is approximately 2.1 million (city proper). I have both pieces of information and am confident in them.
+
+  FINAL ANSWER: The capital of France is Paris, and its population is approximately 2.1 million.
+
+  ---
+  **Example 2: No Tool Needed, Direct Calculation**
+  Task: "What is the result of 5 + 3 + 1294.678?"
+
+  THOUGHT:
+  This is a direct arithmetic calculation. I do not need external tools. I will compute this directly.
+  5 + 3 = 8.
+  8 + 1294.678 = 1302.678.
+
+  FINAL ANSWER: 1302.678
+
+  ---
+  **Example 3: Question Where Answer CANNOT Be Found/Verified**
+  Task: "What was the color of the first car Julius Caesar owned?"
+
+  THOUGHT:
+  Julius Caesar lived from 100 BC to 44 BC. Automobiles were invented in the late 19th century.
+  Therefore, Julius Caesar could not have owned a car. I do not need any tools to determine this; it's based on historical common knowledge.
+
+  FINAL ANSWER: I cannot provide a verified answer to this question based on the available information, as cars were not invented during Julius Caesar's lifetime.
+
+  ---
+  **Example 4: Multiple Tools & Synthesis (Handling Ambiguity/Multiple Pieces of Info)**
+  Task: "Who starred in the movie 'Inception' and what is its main genre according to Wikipedia?"
+
+  THOUGHT:
+  My plan is to:
+  1. Use `web_search` to find a list of main actors in 'Inception'.
+  2. Use `wiki_search` specifically for the Wikipedia page of 'Inception' to find its genre(s).
+  3. Synthesize this information.
+  I will start by searching for the actors.
+
+  (LLM generates tool call for `web_search(query="actors in Inception movie")`. Assume observation returns a list of key actors.)
+
+  THOUGHT:
+  (Observation from web_search: "Key actors in Inception include Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, Tom Hardy, Ken Watanabe, Cillian Murphy, Marion Cotillard, Michael Caine.")
+  The main actors include Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, and Tom Hardy, among others. Now I need the genre from Wikipedia.
+  I will use `wiki_search(query="Inception (film)")`.
+
+  (LLM generates tool call for `wiki_search(query="Inception (film)")`. Assume observation returns relevant Wikipedia text.)
+
+  THOUGHT:
+  (Observation from wiki_search: "...The film is classified as a science fiction action heist film...")
+  The actors are confirmed. Wikipedia lists the genres as "science fiction action heist film". I will report the key actors and this genre description.
+
+  FINAL ANSWER: Key actors in 'Inception' include Leonardo DiCaprio, Joseph Gordon-Levitt, Elliot Page, and Tom Hardy. According to Wikipedia, its genre is science fiction action heist film.
+
+  ---
+  **Example 5: Simple Question, Avoid Over-Complication**
+  Task: "What is two plus two?"
+
+  THOUGHT:
+  This is a basic arithmetic fact. I do not need any external tools.
+
+  FINAL ANSWER: 4
+
+  ---
+  **Example 6: Multi-step Information Retrieval & Refinement (Adapted from Ulam example)**
+  Task: "In a 1979 interview, Stanislaus Ulam discusses Einstein. What single word does he use to describe the consequence of Einstein learning too much math on his creativity?"
+
+  THOUGHT:
+  I need to find the 1979 interview of Stanislaus Ulam, locate his comments about Einstein and mathematics, and extract the specific word describing the consequence on creativity.
+  I will start by using `web_search` with a specific query.
+  I will use `web_search(query="Stanislaus Ulam 1979 interview Einstein creativity mathematics")`.
+
+  (LLM generates tool call. Assume observation comes back.)
+
+  THOUGHT:
+  (Observation from web_search: "No direct answer found, but a link to 'Stanislaus Ulam's Interview (1979) - Atomic Heritage Foundation' seems promising: [https://ahf.nuclearmuseum.org/voices/oral-histories/stanislaus-ulams-interview-1979/]")
+  The initial search didn't give the direct word, but provided a relevant link. I need to process the content of this page. Since I don't have a `visit_webpage` tool that returns full content directly for analysis here, I will try to use `web_search` again, focusing on finding summaries or key quotes from that interview related to Einstein and math.
+  I will use `web_search(query="quotes Stanislaus Ulam 1979 interview Einstein mathematics creativity site:ahf.nuclearmuseum.org")`.
+
+  (LLM generates tool call. Assume observation comes back.)
+
+  THOUGHT:
+  (Observation from web_search: "One search result snippet: '...Ulam recalls Einstein: “He learned too much mathematics and sort of diminished, it seems to me personally, it seems to me his purely physics creativity.”'")
+  This observation directly contains the quote I need. Ulam says Einstein's creativity was "diminished". The question asks for one word.
+
+  FINAL ANSWER: diminished
+
+  ---
+  **Example 7: Comparison using Tool and Logic (Adapted from Guangzhou/Shanghai example)**
+  Task: "Which city has the highest population: Guangzhou or Shanghai?"
+
+  THOUGHT:
+  I need to get the populations for both Guangzhou and Shanghai and then compare them.
+  I will use the `web_search` tool twice, once for each city's population.
+  First, for Guangzhou: `web_search(query="population of Guangzhou")`.
+
+  (LLM generates tool call. Assume observation comes back.)
+
+  THOUGHT:
+  (Observation from web_search: "Guangzhou has a population of approximately 18.7 million as of 2021.")
+  Now for Shanghai: `web_search(query="population of Shanghai")`.
+
+  (LLM generates tool call. Assume observation comes back.)
+
+  THOUGHT:
+  (Observation from web_search: "Shanghai has a population of over 26 million as of 2021.")
+  Comparing the populations: Guangzhou (18.7 million) and Shanghai (over 26 million). Shanghai has a higher population.
+
+  FINAL ANSWER: Shanghai