still working on display part: Refactor LoadStreamlitUI to enhance graph diagram creation and update session recursion limit:

src/langgraphagenticai/graph/graph_builder.py

@@ -4,11 +4,13 @@ from src.langgraphagenticai.nodes.blog_generation_node import BlogGenerationNode
 from src.langgraphagenticai.nodes.basic_chatbot_node import BasicChatbotNode
 from src.langgraphagenticai.nodes.chatbot_with_Tool_node import ChatbotWithToolNode
 from src.langgraphagenticai.tools.search_tool import get_tools, create_tool_nodes
-from langgraph.prebuilt import tools_condition,ToolNode
+from langgraph.prebuilt import tools_condition, ToolNode
 from src.langgraphagenticai.state.state import State
 from langgraph.checkpoint.memory import MemorySaver
 from pydantic import BaseModel, Field
+from langchain_core.messages import SystemMessage, HumanMessage
 import logging
+import json
 
 logger = logging.getLogger(__name__)
 
@@ -21,6 +23,84 @@ class GraphBuilder:
         self.llm = llm
         self.memory = MemorySaver()
 
+    def validate_and_standardize_structure(self, user_input: str) -> list:
+        """
+        Uses an LLM to interpret user input and generate a standardized list of blog section names.
+        Ensures the user's specified structure is respected if provided.
+        
+        Args:
+            user_input (str): The full user input from the Streamlit form (e.g., "Topic: AI\nStructure: Intro, Benefits, Summary").
+        
+        Returns:
+            List[str]: A list of standardized section names (e.g., ["Intro", "Benefits", "Summary"]).
+        """
+        # Default structure if all else fails
+        default_structure = ["Introduction", "Main Content", "Conclusion"]
+
+        # If input is empty or whitespace-only, return default
+        if not user_input or not user_input.strip():
+            logger.info("Empty or whitespace-only input; returning default structure")
+            return default_structure
+
+        # Extract the user's structure if provided
+        user_structure = None
+        for line in user_input.split("\n"):
+            if line.lower().startswith("structure:"):
+                user_structure = line.split(":", 1)[1].strip()
+                break
+
+        # Define the prompt for the LLM
+        system_prompt = (
+            "You are an expert blog planner. Your task is to analyze the user's input and extract or infer a clear, concise structure "
+            "for a blog post as a list of section names. The input may explicitly list sections (e.g., 'Structure: Intro, Benefits, Summary') "
+            "or describe them implicitly (e.g., 'I want an intro, some benefits, and a conclusion'). "
+            "If the user provides a 'Structure' field (e.g., 'Structure: Intro, Benefits, Summary'), you MUST use those exact section names "
+            "without modification, except for capitalizing the first letter of each section. "
+            "If no structure is provided or it's unclear, propose a logical default structure based on the topic or context. "
+            "Return the result as a JSON object with a single key 'sections' containing the list of section names. "
+            "Capitalize each section name and avoid adding unnecessary sections beyond what’s indicated."
+        )
+
+        # Prepare messages for the LLM
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=f"User input: {user_input}")
+        ]
+
+        try:
+            # Invoke the LLM and expect a JSON response
+            response = self.llm.invoke(messages)
+            response_content = response.content if hasattr(response, "content") else str(response)
+            logger.info(f"LLM response for structure: {response_content}")
+
+            # Parse the JSON response
+            result = json.loads(response_content)
+            sections = result.get("sections", default_structure)
+
+            # Validate and standardize the output
+            if not isinstance(sections, list) or not sections:
+                logger.warning("LLM returned invalid sections; using default structure")
+                return default_structure
+            
+            # Clean up section names: strip whitespace, capitalize, remove empty strings
+            cleaned_sections = [s.strip().capitalize() for s in sections if s.strip()]
+
+            # If user provided a structure, enforce it
+            if user_structure:
+                user_sections = [s.strip().capitalize() for s in user_structure.split(",") if s.strip()]
+                if len(cleaned_sections) == len(user_sections):
+                    # Override LLM sections with user sections if lengths match
+                    cleaned_sections = user_sections
+                else:
+                    logger.warning(f"LLM section count ({len(cleaned_sections)}) doesn't match user section count ({len(user_sections)}); using user structure")
+                    cleaned_sections = user_sections
+
+            return cleaned_sections if cleaned_sections else default_structure
+
+        except Exception as e:
+            logger.error(f"Error in LLM structure generation: {e}")
+            return default_structure
+
     def basic_chatbot_build_graph(self):
         """
         Builds a graph for the Basic Chatbot use case.
@@ -38,10 +118,9 @@ class GraphBuilder:
         """
         graph_builder = StateGraph(state_schema=State)
         
-         ## Define the tool and tool node
-
-        tools=get_tools()
-        tool_node=create_tool_nodes(tools)
+        # Define the tool and tool node
+        tools = get_tools()
+        tool_node = create_tool_nodes(tools)
 
         # Define chatbot node
         chatbot_with_tool_node = ChatbotWithToolNode(self.llm)
@@ -51,35 +130,28 @@ class GraphBuilder:
         graph_builder.add_node("tools", tool_node)
         
         graph_builder.add_edge(START, "chatbot")
-        graph_builder.add_conditional_edges("chatbot",tools_condition,)
+        graph_builder.add_conditional_edges("chatbot", tools_condition)
         graph_builder.add_edge("tools", "chatbot")
         return graph_builder.compile(checkpointer=self.memory)
 
     def blog_generation_build_graph(self):
         """
-        Builds a graph for the Blog Generation use case with button-based feedback.
+        Builds a graph for the Blog Generation use case with button-based feedback and LLM-driven structure generation.
         """
         try:
             if not self.llm:
                 raise ValueError("LLM model not initialized")
 
-            # Add structure validation helper
-            def validate_and_standardize_structure(structure: str) -> list:
-                if not structure or structure.strip() == "":
-                    return ["Introduction", "Main Content", "Conclusion"]
-                sections = [s.strip().capitalize() for s in structure.split(",")]
-                if len(sections) < 1:
-                    return ["Introduction", "Main Content", "Conclusion"]
-                return sections
-
             graph_builder = StateGraph(state_schema=State)
             blog_node = BlogGenerationNode(self.llm)
             
-            # Modify user_input node to include structure validation
+            # Modify user_input node to use LLM for structure
             def user_input_with_validation(state: State) -> dict:
-                result = blog_node.user_input(state)
-                raw_structure = result.get("structure", "")
-                result["structure"] = ", ".join(validate_and_standardize_structure(raw_structure))
+                user_message = state["messages"][-1].content if state["messages"] else ""
+                result = blog_node.user_input(state)  # Initial parsing
+                # Use LLM to interpret full user input for structure
+                full_input = user_message  # Use raw message for maximum context
+                result["structure"] = ", ".join(self.validate_and_standardize_structure(full_input))
                 logger.info(f"Validated structure: {result['structure']}")
                 return result
 

src/langgraphagenticai/main.py

@@ -71,7 +71,7 @@ def load_langgraph_agenticai_app():
     if "current_usecase" not in st.session_state:
         st.session_state.current_usecase = None
 
-    config = {"configurable": {"session_id": st.session_state.session_id, "thread_id": st.session_state.thread_id, "recursion_limit": 50}}
+    config = {"configurable": {"session_id": st.session_state.session_id, "thread_id": st.session_state.thread_id, "recursion_limit": 10}}
     logger.info(f"Session ID: {st.session_state.session_id}, Thread ID: {st.session_state.thread_id}")
 
     # Load LLM

src/langgraphagenticai/tools/search_tool.py

@@ -20,6 +20,9 @@ def get_tools(max_results=3):
         return []
 
 def create_tool_nodes(tools):
+    """
+    Creates tool nodes based on the provided tools.
+    """
     try:
         if not tools:
             st.error("Error: No tools provided")

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -1,5 +1,8 @@
 import streamlit as st
 from langchain_core.messages import HumanMessage, AIMessage
+import logging
+
+logger = logging.getLogger(__name__)
 
 class DisplayResultStreamlit:
     def __init__(self, graph, with_message_history, config, usecase):
@@ -7,14 +10,35 @@ class DisplayResultStreamlit:
         self.with_message_history = with_message_history
         self.config = config
         self.usecase = usecase
+        # Initialize session state defaults
+        self._initialize_session_state()
         self.session_history = self._get_session_history()
 
+    def _initialize_session_state(self):
+        """Initialize all session state variables."""
+        defaults = {
+            "waiting_for_feedback": False,
+            "blog_requirements_collected": False,
+            "outline_displayed": False,
+            "draft_displayed": False,
+            "graph_state": None,
+            "current_session_id": None
+        }
+        for key, value in defaults.items():
+            if key not in st.session_state:
+                st.session_state[key] = value
+
     def _get_session_history(self):
         from langchain_community.chat_message_histories import ChatMessageHistory
         store = {}
         session_id = self.config["configurable"]["session_id"]
         if session_id not in store:
             store[session_id] = ChatMessageHistory()
+        # Reset display flags if session ID changes
+        if st.session_state.current_session_id != session_id:
+            st.session_state.outline_displayed = False
+            st.session_state.draft_displayed = False
+            st.session_state.current_session_id = session_id
         return store[session_id]
 
     def display_chat_history(self):
@@ -32,6 +56,13 @@ class DisplayResultStreamlit:
             self._handle_chatbot_input()
 
     def _handle_blog_generation(self):
+        # Fallback: Check graph state if waiting_for_feedback isn't set
+        if not st.session_state.waiting_for_feedback and st.session_state.graph_state:
+            graph_state = st.session_state.graph_state
+            if graph_state.next and graph_state.next[0] in ["outline_review", "draft_review"]:
+                logger.info("Fallback: Setting waiting_for_feedback based on graph state")
+                st.session_state.waiting_for_feedback = True
+
         if st.session_state.waiting_for_feedback:
             self._process_feedback()
         elif not st.session_state.blog_requirements_collected:
@@ -64,11 +95,22 @@ class DisplayResultStreamlit:
                 self.session_history.add_user_message(user_message)
                 with st.chat_message("user"):
                     st.markdown(user_message)
+                # Reset display flags for new blog generation
+                st.session_state.outline_displayed = False
+                st.session_state.draft_displayed = False
                 st.session_state.blog_requirements_collected = True
                 self._process_graph_stream(HumanMessage(content=user_message))
 
     def _process_feedback(self):
         latest_state = st.session_state.graph_state.values if st.session_state.graph_state else {}
+        # Display the outline if it hasn't been displayed yet
+        if "sections" in latest_state and not st.session_state.get("outline_displayed", False):
+            with st.chat_message("assistant"):
+                outline_text = "### Generated Outline\n\n" + "\n\n".join(f"**{s['name']}**: {s['description']}" for s in latest_state["sections"])
+                st.markdown(outline_text)
+                st.markdown("Please review the outline above.")
+                st.session_state.outline_displayed = True
+
         if "completed_sections" in latest_state and not st.session_state.get("draft_displayed", False):
             with st.chat_message("assistant"):
                 draft_content = "\n\n".join(latest_state["completed_sections"])
@@ -77,6 +119,7 @@ class DisplayResultStreamlit:
                 st.session_state.draft_displayed = True
 
         current_node = st.session_state.graph_state.next[0] if st.session_state.graph_state.next else None
+        logger.info(f"Current node in _process_feedback: {current_node}")
         if current_node == "outline_review":
             st.write("Review the outline:")
             col1, col2 = st.columns(2)
@@ -84,10 +127,12 @@ class DisplayResultStreamlit:
                 if st.button("Looks good", key="outline_approve"):
                     st.session_state.outline_feedback = "approved"
                     st.session_state.waiting_for_feedback = False
+                    logger.info("Outline approved")
             with col2:
                 if st.button("Add more details", key="outline_reject"):
                     st.session_state.outline_feedback = "add_more_details"
                     st.session_state.waiting_for_feedback = False
+                    logger.info("Outline regeneration requested")
         elif current_node == "draft_review":
             st.write("Review the draft:")
             col1, col2 = st.columns(2)
@@ -96,11 +141,13 @@ class DisplayResultStreamlit:
                     st.session_state.draft_feedback = "approved"
                     st.session_state.waiting_for_feedback = False
                     st.session_state.draft_displayed = False
+                    logger.info("Draft approved")
             with col2:
                 if st.button("Add more details", key="draft_reject"):
                     st.session_state.draft_feedback = "add_more_details"
                     st.session_state.waiting_for_feedback = False
                     st.session_state.draft_displayed = False
+                    logger.info("Draft regeneration requested")
 
         if not st.session_state.waiting_for_feedback:
             self._process_graph_stream()
@@ -115,35 +162,42 @@ class DisplayResultStreamlit:
 
     def _process_graph_stream(self, input_message=None):
         with st.spinner("Processing..."):
-            input_data = {"messages": [input_message]} if input_message else None
-            for event in (self.graph.stream(input_data, self.config) if input_data else self.graph.stream(None, self.config)):
-                for node, state in event.items():
-                    if "messages" in state and state["messages"]:
+            try:
+                input_data = {"messages": [input_message]} if input_message else None
+                for event in (self.graph.stream(input_data, self.config) if input_data else self.graph.stream(None, self.config)):
+                    logger.info(f"Graph event: {event}")
+                    for node, state in event.items():
+                        if "messages" in state and state["messages"]:
+                            with st.chat_message("assistant"):
+                                self._display_result(state)
+                            self.session_history.add_ai_message(state["messages"][-1].content)
+                    graph_state = self.graph.get_state(self.config)
+                    logger.info(f"Graph state next: {graph_state.next}")
+                    if graph_state.next and graph_state.next[0] in ["outline_review", "draft_review"]:
+                        st.session_state.waiting_for_feedback = True
+                        st.session_state.graph_state = graph_state
+                        logger.info(f"Paused at {graph_state.next[0]} for feedback")
+                        st.rerun()  # Force UI update to ensure feedback buttons appear
+                        break
+                    elif not graph_state.next and self.usecase == "Blog Generation":
+                        st.session_state.blog_requirements_collected = False
+                        st.session_state.outline_displayed = False  # Reset for new blog
+                        st.session_state.draft_displayed = False  # Reset for new blog
                         with st.chat_message("assistant"):
-                            self._display_result(state)
-                        self.session_history.add_ai_message(state["messages"][-1].content)
-                graph_state = self.graph.get_state(self.config)
-                if graph_state.next and graph_state.next[0] in ["outline_review", "draft_review"]:
-                    st.session_state.waiting_for_feedback = True
-                    st.session_state.graph_state = graph_state
-                    break
-                elif not graph_state.next and self.usecase == "Blog Generation":
-                    st.session_state.blog_requirements_collected = False
-                    with st.chat_message("assistant"):
-                        st.markdown("✅ Blog generation completed!")
-                    if st.button("New Blog Generation"):
-                        self.session_history.clear()
-                        st.session_state.graph_state = None
-                        st.session_state.waiting_for_feedback = False
-                        st.rerun()
+                            st.markdown("✅ Blog generation completed!")
+                        if st.button("New Blog Generation"):
+                            self.session_history.clear()
+                            st.session_state.graph_state = None
+                            st.session_state.waiting_for_feedback = False
+                            st.rerun()
+            except Exception as e:
+                logger.error(f"Error in graph streaming: {e}")
+                st.error(f"Error processing workflow: {e}")
 
     def _display_result(self, response):
+        logger.info(f"Display result response: {response}")
         if self.usecase == "Blog Generation":
-            if "sections" in response and not st.session_state.get("outline_displayed", False):
-                outline_text = "### Generated Outline\n\n" + "\n\n".join(f"**{s['name']}**: {s['description']}" for s in response["sections"])
-                st.markdown(outline_text)
-                st.markdown("Please review the outline above.")
-                st.session_state.outline_displayed = True
+            # Outline display moved to _process_feedback
             messages = response.get("messages", [])
             if messages:
                 content = messages[-1].content

src/langgraphagenticai/ui/streamlitui/loadui.py

@@ -24,41 +24,64 @@ class LoadStreamlitUI:
         }
 
     def create_graph_diagram(self, usecase):
-        """Create a graph diagram for the selected use case using GraphBuilder."""
+        """Create a graph diagram for the selected use case based on GraphBuilder's structure."""
         dot = graphviz.Digraph(comment=f"{usecase} Graph", format="png")
+        dot.attr(rankdir="TB")  # Top-to-bottom layout for clarity
 
-        # Define graph structure based on use case
         if usecase == "Basic Chatbot":
+            # Nodes
             dot.node("START", "START")
             dot.node("chatbot", "Chatbot")
             dot.node("END", "END")
-            dot.edges([("START", "chatbot"), ("chatbot", "END")])
+            # Edges
+            dot.edge("START", "chatbot")
+            dot.edge("chatbot", "END")
+        
         elif usecase == "Chatbot with Tool":
+            # Nodes
             dot.node("START", "START")
             dot.node("chatbot", "Chatbot")
             dot.node("tools", "Tools")
             dot.node("END", "END")
-            dot.edges([("START", "chatbot"), ("chatbot", "tools"), ("tools", "chatbot")])
-            dot.edge("chatbot", "chatbot", label="conditional", style="dashed")
+            # Edges
+            dot.edge("START", "chatbot")
+            dot.edge("chatbot", "tools", label="tools_condition", style="dashed", constraint="false")
+            dot.edge("tools", "chatbot", label="return")
+            dot.edge("chatbot", "END", label="no tools", style="dashed", constraint="false")
+        
         elif usecase == "Blog Generation":
+            # Nodes
             dot.node("START", "START")
-            dot.node("orchestrator", "Orchestrator")
-            dot.node("llm_call", "LLM Call (Workers)")
-            dot.node("synthesizer", "Synthesizer")
+            dot.node("user_input", "User Input")
+            dot.node("outline_generator", "Outline Generator")
+            dot.node("outline_review", "Outline Review\n(Human)", shape="diamond")
+            dot.node("web_search", "Web Search")
+            dot.node("draft_generator", "Draft Generator")
+            dot.node("draft_review", "Draft Review\n(Human)", shape="diamond")
+            dot.node("revision_generator", "Revision Generator")
             dot.node("END", "END")
-            dot.edges([
-                ("START", "orchestrator"),
-                ("llm_call", "synthesizer"),
-                ("synthesizer", "END"),
-                
-            ])
-            dot.edge("orchestrator", "llm_call", label="parallel", style="dashed")
-            dot.edge("llm_call", "synthesizer", label="parallel", style="dashed")
-        elif usecase == "Coding Peer Review":
+            # Static Edges
+            dot.edge("START", "user_input")
+            dot.edge("user_input", "outline_generator")
+            dot.edge("outline_generator", "outline_review")
+            dot.edge("web_search", "draft_generator")
+            dot.edge("revision_generator", "draft_review")
+            # Conditional Edges for outline_review
+            dot.edge("outline_review", "draft_generator", label="approved", style="dashed", color="green")
+            dot.edge("outline_review", "outline_generator", label="add details", style="dashed", color="orange", constraint="false")
+            # Conditional Edges for draft_generator
+            dot.edge("draft_generator", "web_search", label="needs facts", style="dashed", color="blue")
+            dot.edge("draft_generator", "draft_review", label="has facts", style="dashed", color="green")
+            # Conditional Edges for draft_review
+            dot.edge("draft_review", "END", label="approved", style="dashed", color="green")
+            dot.edge("draft_review", "revision_generator", label="add details", style="dashed", color="orange", constraint="false")
+        
+        # Note: Coding Peer Review not implemented in GraphBuilder, so skipping it
+        else:
             dot.node("START", "START")
-            dot.node("reviewer", "Reviewer")
+            dot.node("unknown", f"Unknown Use Case:\n{usecase}")
             dot.node("END", "END")
-            dot.edges([("START", "reviewer"), ("reviewer", "END")])
+            dot.edges([("START", "unknown"), ("unknown", "END")])
 
         return dot