ssgrummons changes

Signed-off-by: apple muncy <[email protected]>

app.py

@@ -1,19 +1,119 @@
+from typing import TypedDict, Annotated
+from langgraph.graph.message import add_messages
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, SystemMessage
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+
+from tools import search_tool, weather_info_tool, hub_stats_tool
+
+
 import gradio as gr
-import random
+
+
 from smolagents import GradioUI, CodeAgent, HfApiModel
 
 
 from retriever import load_guest_dataset
 
+from dotenv import load_dotenv
+import yaml
+load_dotenv()
+
+# Import our custom tools from their modules
+from retriever import load_guest_dataset
+
+
+# Import our custom tools from their modules
+from retriever import load_guest_dataset
+
 model = HfApiModel()
 guest_info_tool = load_guest_dataset()
 
-alfred = CodeAgent(
-        tools=[guest_info_tool],
-        model=model,
-        add_base_tools=True,
-        planning_interval=3   # Enable planning every 3 steps
+# Load prompts from YAML file
+with open("prompts.yaml", 'r') as stream:
+    prompt_templates = yaml.safe_load(stream)
+
+# Get the system prompt from the YAML file
+system_prompt = prompt_templates["system_prompt"]
+
+# Initialize the chat model
+chat = ChatOllama(model="qwen2:7b",
+                verbose=True)
+
+# Define available tools
+tools = [
+        load_guest_dataset, 
+        search_tool, 
+        weather_info_tool, 
+        hub_stats_tool
+        ]
+
+# Bind tools to the chat model
+chat_with_tools = chat.bind_tools(tools)
+
+# Generate the AgentState and Agent graph
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+
+
+def assistant(state: AgentState):
+    # If this is the first message, add the system prompt
+    if len(state["messages"]) == 1 and isinstance(state["messages"][0], HumanMessage):
+        # Add system message with the ReAct framework prompt
+        messages = [SystemMessage(content=system_prompt)] + state["messages"]
+    else:
+        messages = state["messages"]
+
+    return {
+        "messages": [chat_with_tools.invoke(messages)],
+    }
+
+
+## The graph
+builder = StateGraph(AgentState)
+
+# Define nodes: these do the work
+builder.add_node("assistant", assistant)
+builder.add_node("tools", ToolNode(tools))
+
+# Define edges: these determine how the control flow moves
+builder.add_edge(START, "assistant")
+builder.add_conditional_edges(
+    "assistant",
+    # If the latest message requires a tool, route to tools
+    # Otherwise, provide a direct response
+    tools_condition,
 )
+builder.add_edge("tools", "assistant")
+graph_app = builder.compile()
+
+graph_state = {}
+
+# Gradio expects a function with (chat_history, user_message) -> (updated_chat_history)
+def chat_fn(message, history):
+    session_id = "session-123"
+
+    result = graph_app.invoke(
+        {"messages": [HumanMessage(content=message)]},
+        config={"configurable": {"thread_id": session_id}}
+    )
+
+    response = result["messages"][-1].content
+    history.append((message, response))
+    return history, ""
+
  
+# Create Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("### LangGraph Chat with Gradio")
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox(label="Type your message")
+    send_btn = gr.Button("Send")
+
+    # Hook the send button
+    send_btn.click(fn=chat_fn, inputs=[msg, chatbot], outputs=[chatbot, msg])
+
+
 if __name__ == "__main__":
-    GradioUI(alfred).launch()
+    demo.launch()

prompts.yaml

@@ -0,0 +1,131 @@
+"system_prompt": |-
+  You are an expert assistant who can solve any task using available tools. You will be given a task to solve as best you can.
+  To do so, you have been given access to a list of tools: these tools are Python functions which you can call directly.
+  To solve the task, you should follow the ReAct framework: Reason, Act, and Observe.
+
+  At each step, you should:
+  1. Reason: Explain your thinking about the task and which tools you want to use
+  2. Act: Call the appropriate tools with the correct parameters
+  3. Observe: Use the results from the tools to inform your next steps
+
+  Here are the tools available to you:
+  {%- for tool in tools.values() %}
+  - {{ tool.name }}: {{ tool.description }}
+      Takes inputs: {{tool.inputs}}
+      Returns an output of type: {{tool.output_type}}
+  {%- endfor %}
+
+  Here are the rules you should always follow:
+  1. Always explain your reasoning before using a tool
+  2. Use only the tools that are available to you
+  3. Always use the right arguments for the tools
+  4. Take care to not chain too many sequential tool calls in the same response
+  5. Call a tool only when needed, and never re-do a tool call that you previously did with the exact same parameters
+  6. Don't give up! You're in charge of solving the task
+
+  Now Begin!
+"planning":
+  "initial_facts": |-
+    Below I will present you a task.
+
+    You will now build a comprehensive preparatory survey of which facts we have at our disposal and which ones we still need.
+    To do so, you will have to read the task and identify things that must be discovered in order to successfully complete it.
+    Don't make any assumptions. For each item, provide a thorough reasoning. Here is how you will structure this survey:
+
+    ---
+    ### 1. Facts given in the task
+    List here the specific facts given in the task that could help you (there might be nothing here).
+
+    ### 2. Facts to look up
+    List here any facts that we may need to look up.
+    Also list where to find each of these, for instance a website, a file... - maybe the task contains some sources that you should re-use here.
+
+    ### 3. Facts to derive
+    List here anything that we want to derive from the above by logical reasoning, for instance computation or simulation.
+
+    Keep in mind that "facts" will typically be specific names, dates, values, etc. Your answer should use the below headings:
+    ### 1. Facts given in the task
+    ### 2. Facts to look up
+    ### 3. Facts to derive
+    Do not add anything else.
+  "initial_plan": |-
+    You are a world expert at making efficient plans to solve any task using a set of carefully crafted tools.
+
+    Now for the given task, develop a step-by-step high-level plan taking into account the above inputs and list of facts.
+    This plan should involve individual tasks based on the available tools, that if executed correctly will yield the correct answer.
+    Do not skip steps, do not add any superfluous steps. Only write the high-level plan, DO NOT DETAIL INDIVIDUAL TOOL CALLS.
+    After writing the final step of the plan, write the '\n<end_plan>' tag and stop there.
+
+    Here is your task:
+
+    Task:
+    ```
+    {{task}}
+    ```
+    You can leverage these tools:
+    {%- for tool in tools.values() %}
+    - {{ tool.name }}: {{ tool.description }}
+        Takes inputs: {{tool.inputs}}
+        Returns an output of type: {{tool.output_type}}
+    {%- endfor %}
+
+    List of facts that you know:
+    ```
+    {{answer_facts}}
+    ```
+
+    Now begin! Write your plan below.
+  "update_facts_pre_messages": |-
+    You are a world expert at gathering known and unknown facts based on a conversation.
+    Below you will find a task, and a history of attempts made to solve the task. You will have to produce a list of these:
+    ### 1. Facts given in the task
+    ### 2. Facts that we have learned
+    ### 3. Facts still to look up
+    ### 4. Facts still to derive
+    Find the task and history below:
+  "update_facts_post_messages": |-
+    Earlier we've built a list of facts.
+    But since in your previous steps you may have learned useful new facts or invalidated some false ones.
+    Please update your list of facts based on the previous history, and provide these headings:
+    ### 1. Facts given in the task
+    ### 2. Facts that we have learned
+    ### 3. Facts still to look up
+    ### 4. Facts still to derive
+
+    Now write your new list of facts below.
+  "update_plan_pre_messages": |-
+    You are a world expert at making efficient plans to solve any task using a set of carefully crafted tools.
+
+    You have been given a task:
+    ```
+    {{task}}
+    ```
+
+    Find below the record of what has been tried so far to solve it. Then you will be asked to make an updated plan to solve the task.
+    If the previous tries so far have met some success, you can make an updated plan based on these actions.
+    If you are stalled, you can make a completely new plan starting from scratch.
+  "update_plan_post_messages": |-
+    You're still working towards solving this task:
+    ```
+    {{task}}
+    ```
+
+    You can leverage these tools:
+    {%- for tool in tools.values() %}
+    - {{ tool.name }}: {{ tool.description }}
+        Takes inputs: {{tool.inputs}}
+        Returns an output of type: {{tool.output_type}}
+    {%- endfor %}
+
+    Here is the up to date list of facts that you know:
+    ```
+    {{facts_update}}
+    ```
+
+    Now for the given task, develop a step-by-step high-level plan taking into account the above inputs and list of facts.
+    This plan should involve individual tasks based on the available tools, that if executed correctly will yield the correct answer.
+    Beware that you have {remaining_steps} steps remaining.
+    Do not skip steps, do not add any superfluous steps. Only write the high-level plan, DO NOT DETAIL INDIVIDUAL TOOL CALLS.
+    After writing the final step of the plan, write the '\n<end_plan>' tag and stop there.
+
+    Now write your new plan below.

requirements.txt

@@ -2,3 +2,11 @@ datasets
 smolagents 
 langchain-community
 rank_bm25
+gradio
+litellm
+langchain
+langchain-litellm
+langgraph
+langchain-huggingface
+langchain-ollama
+dotenv

retriever.py

@@ -1,7 +1,6 @@
 from smolagents import Tool
 from langchain_community.retrievers import BM25Retriever
 from langchain.docstore.document import Document
-
 import datasets
 
 class GuestInfoRetrieverTool(Tool):
@@ -31,7 +30,6 @@ class GuestInfoRetrieverTool(Tool):
 def load_guest_dataset():
     # Load the dataset
     guest_dataset = datasets.load_dataset("agents-course/unit3-invitees", split="train")
-    print (guest_dataset)
     # Convert dataset entries into Document objects
     docs = [
         Document(

tools.py

@@ -1,18 +1,47 @@
-from langchain_community.retrievers import BM25Retriever
+from langchain_community.tools import DuckDuckGoSearchRun
+import random
+
 from langchain.tools import Tool
 
-bm25_retriever = BM25Retriever.from_documents(docs)
+def get_weather_info(location: str) -> str:
+    """Fetches dummy weather information for a given location."""
+    # Dummy weather data
+    weather_conditions = [
+        {"condition": "Rainy", "temp_c": 15},
+        {"condition": "Clear", "temp_c": 25},
+        {"condition": "Windy", "temp_c": 20}
+    ]
+    # Randomly select a weather condition
+    data = random.choice(weather_conditions)
+    return f"Weather in {location}: {data['condition']}, {data['temp_c']}°C"
+
+# Initialize the tool
+weather_info_tool = Tool(
+    name="get_weather_info",
+    func=get_weather_info,
+    description="Fetches dummy weather information for a given location."
+)
+
 
-def extract_text(query: str) -> str:
-    """Retrieves detailed information about gala guests based on their name or relation."""
-    results = bm25_retriever.invoke(query)
-    if results:
-        return "\n\n".join([doc.page_content for doc in results[:3]])
-    else:
-        return "No matching guest information found."
+def get_hub_stats(author: str) -> str:
+    """Fetches the most downloaded model from a specific author on the Hugging Face Hub."""
+    try:
+        # List models from the specified author, sorted by downloads
+        models = list(list_models(author=author, sort="downloads", direction=-1, limit=1))
 
-guest_info_tool = Tool(
-    name="guest_info_retriever",
-    func=extract_text,
-    description="Retrieves detailed information about gala guests based on their name or relation."
+        if models:
+            model = models[0]
+            return f"The most downloaded model by {author} is {model.id} with {model.downloads:,} downloads."
+        else:
+            return f"No models found for author {author}."
+    except Exception as e:
+        return f"Error fetching models for {author}: {str(e)}"
+
+# Initialize the tool
+hub_stats_tool = Tool(
+    name="get_hub_stats",
+    func=get_hub_stats,
+    description="Fetches the most downloaded model from a specific author on the Hugging Face Hub."
 )
+
+