almost there

graph.py

@@ -101,7 +101,15 @@ class GraphProcessingState(BaseModel):
     prompt: str = Field(default_factory=str, description="The prompt to be used for the model")
     tools_enabled: dict = Field(default_factory=dict, description="The tools enabled for the assistant")
     search_enabled: bool = Field(default=True, description="Whether to enable search tools")
+    next_stage: str = Field(default="", description="The next stage to execute, decided by the guidance node.")
+
+    # Completion flags for each stage
     idea_complete: bool = Field(default=False)
+    brainstorming_complete: bool = Field(default=False)
+    planning_complete: bool = Field(default=False)
+    drawing_complete: bool = Field(default=False)
+    product_searching_complete: bool = Field(default=False)
+    purchasing_complete: bool = Field(default=False)
 
 
 async def planning_node(state: GraphProcessingState, config=None):
@@ -166,38 +174,63 @@ async def assistant_node(state: GraphProcessingState, config=None):
         "idea_complete": idea_complete
     }
 
-async def chatbot(state: GraphProcessingState, config=None):
-    assistant_tools = []
-    if state.tools_enabled.get("download_website_text", True):
-        assistant_tools.append(download_website_text)
-    if search_enabled and state.tools_enabled.get("tavily_search_results_json", True):
-        assistant_tools.append(tavily_search_tool)
-    assistant_model = model.bind_tools(assistant_tools)
+    # message = llm_with_tools.invoke(state["messages"])
+    # Because we will be interrupting during tool execution,
+    # we disable parallel tool calling to avoid repeating any
+    # tool invocations when we resume.
+    assert len(response.tool_calls) <= 1
+    idea_complete = evaluate_idea_completion(response)
+
+    return {
+        "messages": response,
+        "idea_complete": idea_complete
+    }
+
+async def guidance_node(state: GraphProcessingState, config=None):
+    # Define the guiding system prompt
+
+    # Prepare context: stage completion statuses
+    stage_order = ["brainstorming", "planning", "drawing", "product_searching", "purchasing"]
+    completed = [stage for stage in stage_order if getattr(state, f"{stage}_complete", False)]
+    incomplete = [stage for stage in stage_order if not getattr(state, f"{stage}_complete", False)]
+
+    status_summary = f"Completed stages: {completed}\nIncomplete stages: {incomplete}"
+
+    guidance_prompt = (
+        "You are the guiding assistant. Based on the user's input and the current project status, "
+        "help decide the next stage in the DIY process. Ask the user which stage to continue next if needed.\n\n"
+        f"CURRENT STATUS:\n{status_summary}\n\n"  # <-- The information was moved here
+        "Available stages: brainstorming, planning, drawing, product_searching, purchasing."
+    )
+
+    # Build final prompt with base and current prompt
     if state.prompt:
-        final_prompt = "\n".join([state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
+        final_prompt = "\n".join([guidance_prompt, state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
     else:
-        final_prompt = ASSISTANT_SYSTEM_PROMPT_BASE
+        final_prompt = "\n".join([guidance_prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
 
+    # Create prompt template
     prompt = ChatPromptTemplate.from_messages(
         [
             ("system", final_prompt),
             MessagesPlaceholder(variable_name="messages"),
         ]
     )
+
+    # Bind tools if needed (minimal here, mostly guidance)
+    assistant_model = model.bind_tools([])
+
+    # Create the chain
     chain = prompt | assistant_model
 
-    response = await chain.ainvoke({"messages": state.messages}, config=config)
+    
 
-    # message = llm_with_tools.invoke(state["messages"])
-    # Because we will be interrupting during tool execution,
-    # we disable parallel tool calling to avoid repeating any
-    # tool invocations when we resume.
-    assert len(response.tool_calls) <= 1
-    idea_complete = evaluate_idea_completion(response)
+    # Get response from assistant
+    response = await chain.ainvoke({"messages": state.messages}, config=config)
 
     return {
         "messages": response,
-        "idea_complete": idea_complete
+        "next_stage": incomplete[0] if incomplete else None
     }
 
 # def assistant_cond_edge(state: GraphProcessingState):
@@ -218,6 +251,22 @@ def assistant_routing(state: GraphProcessingState) -> str:
         logger.info("Idea is incomplete. Routing back to 'assistant_node'.")
         return "assistant_node"
 
+def guidance_routing(state: GraphProcessingState) -> str:
+    next_stage = state.get("next_stage")
+
+    if next_stage == "brainstorming":
+        return "assistant_node"
+    elif next_stage == "planning":
+        return "planning_node"
+    elif next_stage == "drawing":
+        return "tools"
+    elif next_stage == "product_searching":
+        return "assistant_node"
+    elif next_stage == "purchasing":
+        return "assistant_node"
+
+    return END
+
 
 
 def define_workflow() -> CompiledStateGraph:
@@ -229,11 +278,16 @@ def define_workflow() -> CompiledStateGraph:
     workflow.add_node("assistant_node", assistant_node)
     workflow.add_node("tools", ToolNode(tools))
     workflow.add_node("planning_node", planning_node)
+    workflow.add_node("guidance_node", guidance_node)
+
     # workflow.add_node("chatbot", chatbot)
 
     # Edges
-    workflow.add_edge("tools", "assistant_node")
-    workflow.add_edge("planning_node", "assistant_node")
+    workflow.add_edge("tools", "guidance_node")
+    # workflow.add_edge("planning_node", "assistant_node")
+    workflow.add_edge("planning_node", "guidance_node")
+    workflow.add_edge("assistant_node", "guidance_node")
+
 
 
     # workflow.add_conditional_edges(
@@ -245,7 +299,8 @@ def define_workflow() -> CompiledStateGraph:
     # workflow.add_edge(START, "chatbot")
 
     # Conditional routing   
-    workflow.add_conditional_edges("assistant_node", assistant_routing)
+    # workflow.add_conditional_edges("assistant_node", assistant_routing)
+    workflow.add_conditional_edges("guidance_node", guidance_routing)
 
     # # Set end nodes
     workflow.set_entry_point("assistant_node")

oldgraph.py

@@ -1,208 +0,0 @@
-import logging
-import os
-from typing import Annotated
-from typing_extensions import TypedDict
-from pydantic import model_validator
-
-import aiohttp
-from langchain_core.messages import AnyMessage
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_core.tools import tool
-from langgraph.graph.state import CompiledStateGraph
-from langgraph.prebuilt import ToolNode, tools_condition
-from langgraph.graph import StateGraph, START, END, add_messages
-from langchain_community.tools import TavilySearchResults
-from pydantic import BaseModel, Field
-from trafilatura import extract
-from langchain_anthropic import ChatAnthropic
-from langgraph.prebuilt import ToolNode
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.types import Command, interrupt
-
-
-
-
-logger = logging.getLogger(__name__)
-ASSISTANT_SYSTEM_PROMPT_BASE = """"""
-search_enabled = bool(os.environ.get("TAVILY_API_KEY"))
-
-def evaluate_idea_completion(response) -> bool:
-    """
-    Evaluates whether the assistant's response indicates a complete DIY project idea.
-    You can customize the logic based on your specific criteria.
-    """
-    # Example logic: Check if the response contains certain keywords
-    required_keywords = ["materials", "dimensions", "tools", "steps"]
-
-    # Determine the type of response and extract text accordingly
-    if isinstance(response, dict):
-        # If response is a dictionary, extract values and join them into a single string
-        response_text = ' '.join(str(value).lower() for value in response.values())
-    elif isinstance(response, str):
-        # If response is a string, convert it to lowercase
-        response_text = response.lower()
-    else:
-        # If response is of an unexpected type, convert it to string and lowercase
-        response_text = str(response).lower()
-
-    return all(keyword in response_text for keyword in required_keywords)
-
-@tool
-def human_assistance(query: str) -> str:
-    """Request assistance from a human."""
-    human_response = interrupt({"query": query})
-    return human_response["data"]
-
-@tool
-async def download_website_text(url: str) -> str:
-    """Download the text from a website"""
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url) as response:
-                response.raise_for_status()
-                downloaded = await response.text()
-        result = extract(downloaded, include_formatting=True, include_links=True, output_format='json', with_metadata=True)
-        return result or "No text found on the website"
-    except Exception as e:
-        logger.error(f"Failed to download {url}: {str(e)}")
-        return f"Error retrieving website content: {str(e)}"
-
-tools = [download_website_text, human_assistance]
-memory = MemorySaver()
-
-
-if search_enabled:
-    tavily_search_tool = TavilySearchResults(
-        max_results=5,
-        search_depth="advanced",
-        include_answer=True,
-        include_raw_content=True,
-    )
-    tools.append(tavily_search_tool)
-else:
-    print("TAVILY_API_KEY environment variable not found. Websearch disabled")
-
-weak_model = ChatAnthropic(
-            model="claude-3-5-sonnet-20240620",
-            temperature=0,
-            max_tokens=1024,
-            timeout=None,
-            max_retries=2,
-            # other params...
-        )
-model = weak_model
-assistant_model = weak_model
-
-class GraphProcessingState(BaseModel):
-    # user_input: str = Field(default_factory=str, description="The original user input")
-    messages: Annotated[list[AnyMessage], add_messages] = Field(default_factory=list)
-    prompt: str = Field(default_factory=str, description="The prompt to be used for the model")
-    tools_enabled: dict = Field(default_factory=dict, description="The tools enabled for the assistant")
-    search_enabled: bool = Field(default=True, description="Whether to enable search tools")
-    idea_complete: bool = Field(default=False)
-
-    @model_validator(mode="after")
-    def remove_empty_messages(self):
-        """
-        Filters out messages with empty content from the messages list.
-        """
-        if self.messages:
-            filtered_messages = []
-            for msg in self.messages:
-                # Keep the message if its content is not empty.
-                # This handles str content, and list content (for tool calls)
-                if msg.content:
-                    filtered_messages.append(msg)
-            self.messages = filtered_messages
-        return self
-
-
-
-
-
-async def chatbot(state: GraphProcessingState, config=None):
-    assistant_tools = []
-    if state.tools_enabled.get("download_website_text", True):
-        assistant_tools.append(download_website_text)
-    if search_enabled and state.tools_enabled.get("tavily_search_results_json", True):
-        assistant_tools.append(tavily_search_tool)
-    assistant_model = model.bind_tools(assistant_tools)
-    if state.prompt:
-        final_prompt = "\n".join([state.prompt, ASSISTANT_SYSTEM_PROMPT_BASE])
-    else:
-        final_prompt = ASSISTANT_SYSTEM_PROMPT_BASE
-
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            ("system", final_prompt),
-            MessagesPlaceholder(variable_name="messages"),
-        ]
-    )
-    chain = prompt | assistant_model
-
-    valid_messages = [
-        msg for msg in state.messages if (isinstance(msg.content, str) and msg.content.strip()) or (isinstance(msg.content, list) and msg.content)
-    ]
-    
-    # Crucial Debugging Step: If the error persists, print the messages
-    # to see exactly what is being sent.
-    # print("Messages being sent to model:", valid_messages)
-
-    if not valid_messages:
-        # Handle the case where all messages are filtered out
-        # You might want to return a default response or raise an error
-        # For now, we can create a dummy response or just return.
-        return {"messages": [AIMessage(content="I have no valid input to respond to.")]}
-
-
-    response = await chain.ainvoke({"messages": valid_messages}, config=config)
-
-    # message = llm_with_tools.invoke(state["messages"])
-    # Because we will be interrupting during tool execution,
-    # we disable parallel tool calling to avoid repeating any
-    # tool invocations when we resume.
-    assert len(response.tool_calls) <= 1
-    idea_complete = evaluate_idea_completion(response)
-
-    return {
-        "messages": response,
-        "idea_complete": idea_complete
-    }
-
-
-
-
-def define_workflow() -> CompiledStateGraph:
-    """Defines the workflow graph"""
-    # Initialize the graph
-    workflow = StateGraph(GraphProcessingState)
-
-    # Add nodes
-    workflow.add_node("tools", ToolNode(tools))
-    workflow.add_node("chatbot", chatbot)
-
-  
-
-    workflow.add_conditional_edges(
-        "chatbot",
-        tools_condition,
-    )
-
-    workflow.add_edge("tools", "chatbot")
-    workflow.add_edge(START, "chatbot")
-
-    compiled_graph = workflow.compile(checkpointer=memory)
-    try:
-        img_bytes = compiled_graph.get_graph().draw_mermaid_png()
-        with open("graph.png", "wb") as f:
-            f.write(img_bytes)
-        print("Graph image saved as graph.png")
-    except Exception as e:
-        print("Can't print the graph:")
-        print(e)
-
-
-    return compiled_graph
-
-graph = define_workflow()
-