BlogGenerationNode feedback collection to improve JSON parsing and streamline feedback handling

src/langgraphagenticai/graph/graph_builder.py

@@ -163,7 +163,7 @@ class GraphBuilder:
             graph_builder.add_edge("revision_generator", "synthesizer")  # Loop back to synthesize revised sections
 
             # Compile with interrupts at review nodes
-            return graph_builder.compile(interrupt_before=["feedback_collector"], checkpointer=self.memory)
+            return graph_builder.compile(interrupt_after=["feedback_collector"], checkpointer=self.memory)
         except Exception as e:
             logger.error(f"Error building blog generation graph: {e}")
             return None

src/langgraphagenticai/nodes/blog_generation_node.py

@@ -1,27 +1,8 @@
-# # src/langgraphagenticai/nodes/blog_generation_node.py
-# from src.langgraphagenticai.state.state import State, Section
-# from pydantic import BaseModel, Field
-# from typing import List, Dict, Optional
-# from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
-# from langchain_core.prompts import ChatPromptTemplate
-# from src.langgraphagenticai.tools.search_tool import get_tools
-# import logging
-# import streamlit as st
-# import json
-
-# # Configure logging
-# logging.basicConfig(level=logging.INFO)
-# logger = logging.getLogger(__name__)
-
-
-
 import logging
 from langgraph.graph import StateGraph, START, END
 from langgraph.constants import Send
 from src.langgraphagenticai.state.state import State, WorkerState, Sections, Section  # Import from state.py
 from langchain_core.messages import SystemMessage, HumanMessage
-from IPython.display import Markdown, display
-from PIL import Image
 import streamlit as st
 import json
 
@@ -95,30 +76,31 @@ class BlogGenerationNode:
         return {"final_report": final_report}
 
     def feedback_collector(self, state: State) -> dict:
-        """Collect human feedback on the draft using Streamlit interface."""
+        """Collect human feedback on the draft."""
         logger.info("Executing feedback_collector")
         
-        # Get feedback from Streamlit session state
-        feedback = st.session_state.get("draft_feedback", "")
+        # Check if we have a new human message with feedback
+        if state["messages"] and isinstance(state["messages"][-1], HumanMessage):
+            try:
+                # Parse the feedback from the human message
+                feedback_data = json.loads(state["messages"][-1].content)
+                is_approved = feedback_data.get("approved", False)
+                comments = feedback_data.get("comments", "")
+                
+                logger.info(f"Parsed feedback: approved={is_approved}, comments={comments}")
+                
+                return {
+                    "feedback": comments,
+                    "draft_approved": is_approved,
+                    "blog_content": state.get("final_report", "")  # Keep the content in state
+                }
+            except json.JSONDecodeError:
+                # Not a valid JSON feedback
+                logger.warning("Invalid feedback format")
+                return {"feedback": "", "draft_approved": False}
         
-        # Check if feedback exists
-        if feedback:
-            logger.info(f"Collected feedback: {feedback}")
-            # Set draft_approved in state
-            state["draft_approved"] = feedback == "approved"
-            return {
-                "feedback": feedback,
-                "draft_approved": state["draft_approved"]
-            }
-        else:
-            logger.info("No feedback provided yet")
-            # Set draft_approved in state
-            state["draft_approved"] = False
-            return {
-                "feedback": "",
-                "draft_approved": state["draft_approved"]
-            }
-
+        # No feedback yet
+        return {"feedback": "", "draft_approved": False}
     def revision_generator(self,state: State) -> dict:
         """Revise the report based on human feedback."""
         if state["draft_approved"]:

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -59,7 +59,7 @@ class DisplayResultStreamlit:
         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] == "feedback_collector":
-                logger.info("Setting waiting_for_feedback based on graph state")
+                logger.info("\nSetting waiting_for_feedback based on graph state\n")
                 st.session_state.waiting_for_feedback = True
 
         if st.session_state.waiting_for_feedback:
@@ -101,51 +101,62 @@ class DisplayResultStreamlit:
 
     def _process_feedback(self):
         latest_state = st.session_state.graph_state.values if st.session_state.graph_state else {}
+        logger.info(f"Latest state in _process_feedback: {latest_state}")
+        
+        # Look for blog content in the right places
+        blog_content = latest_state.get("final_report", "")
         
         # Display the content if it hasn't been displayed yet
-        if "blog_content" in latest_state and not st.session_state.get("content_displayed", False):
+        if blog_content and not st.session_state.content_displayed:
             with st.chat_message("assistant"):
                 st.markdown("### Generated Blog Content")
-                st.markdown(self._format_blog_content(latest_state["blog_content"]))
+                st.markdown(self._format_blog_content(blog_content))
                 st.session_state.content_displayed = True
+                logger.info("Blog content displayed from _process_feedback")
 
         # Check if we're at the feedback collection node
         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 == "feedback_collector":
-            st.write("### Review the generated content:")
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                if st.button("Approve", key="content_approve"):
-                    feedback = {
-                        "approved": True,
-                        "comments": "Content approved."
-                    }
-                    self._submit_feedback(feedback)
-                    
-            with col2:
-                with st.expander("Request Revisions"):
-                    comments = st.text_area("Provide revision comments:", 
-                                           placeholder="Please explain what changes you would like to see.")
-                    if st.button("Submit Revisions"):
-                        if not comments:
-                            st.error("Please provide revision comments.")
-                        else:
-                            feedback = {
-                                "approved": False,
-                                "comments": comments
-                            }
-                            self._submit_feedback(feedback)
+            # Only show feedback UI if we haven't already shown it
+            if not st.session_state.get("feedback_ui_shown", False):
+                st.write("### Review the generated content:")
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    if st.button("Approve", key="content_approve"):
+                        feedback = {
+                            "approved": True,
+                            "comments": "Content approved."
+                        }
+                        self._submit_feedback(feedback)
+                        
+                with col2:
+                    with st.expander("Request Revisions"):
+                        comments = st.text_area("Provide revision comments:", 
+                                            placeholder="Please explain what changes you would like to see.")
+                        if st.button("Submit Revisions"):
+                            if not comments:
+                                st.error("Please provide revision comments.")
+                            else:
+                                feedback = {
+                                    "approved": False,
+                                    "comments": comments
+                                }
+                                self._submit_feedback(feedback)
+                
+                st.session_state.feedback_ui_shown = True
 
     def _submit_feedback(self, feedback):
         """Submit feedback to the graph and continue processing."""
         try:
-            # Convert feedback to the expected ReviewFeedback format
+            # Convert feedback to the expected format
             feedback_json = json.dumps(feedback)
             st.session_state.waiting_for_feedback = False
             st.session_state.content_displayed = False
+            st.session_state.feedback_ui_shown = False  # Reset this flag
+            
             # Continue processing with the feedback
             self._process_graph_stream(HumanMessage(content=feedback_json))
             logger.info(f"Feedback submitted: {feedback}")
@@ -166,50 +177,54 @@ class DisplayResultStreamlit:
             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}")
+                    logger.info(f"\nGraph event: {event}\n")
+                    
+                    # Check for blog content in each event
                     for node, state in event.items():
+                        # Print the full state for debugging
+                        logger.info(f"\nState from {node}: {state}\n")
+                        
+                        if "final_report" in state:
+                            # Store the final report in session state for access in _process_feedback
+                            if not st.session_state.get("blog_content"):
+                                st.session_state.blog_content = state["final_report"]
+                                logger.info(f"Stored blog content in session state: {state['final_report'][:30]}...")
+                        
                         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)
+                                content = state["messages"][-1].content
+                                st.markdown(content)
+                            self.session_history.add_ai_message(content)
                     
                     graph_state = self.graph.get_state(self.config)
-                    logger.info(f"Graph state next: {graph_state.next}")
+                    logger.info(f"\nGraph state next: {graph_state.next}\n")
                     
                     if graph_state.next and graph_state.next[0] == "feedback_collector":
                         st.session_state.waiting_for_feedback = True
                         st.session_state.graph_state = graph_state
-                        logger.info("Paused for feedback collection")
+                        logger.info("\nPaused for feedback collection\n")
                         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.content_displayed = False  # Reset for new blog
-                        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()
             except Exception as e:
-                logger.error(f"Error in graph streaming: {e}")
-                st.error(f"Error processing workflow: {e}")
+                logger.error(f"\nError in graph streaming: {e}\n")
+                st.error(f"\nError processing workflow: {e}\n")
 
     def _display_result(self, response):
-        logger.info(f"Display result response: {response}")
+        logger.info(f"\nDisplay result response: {response}\n")
+        
         if self.usecase == "Blog Generation":
             messages = response.get("messages", [])
-            if messages:
+            blog_content = response.get("final_report", "")
+            
+            # If we have messages but no blog content, just show the message
+            if messages and not blog_content:
                 content = messages[-1].content
-                blog_content = response.get("blog_content", "")
+                st.markdown(content)
                 
-                if blog_content and not st.session_state.content_displayed:
-                    st.markdown("### Generated Blog Content")
-                    st.markdown(self._format_blog_content(blog_content))
-                    st.session_state.content_displayed = True
-                else:
-                    st.markdown(content)
+            # No need to display blog content here - it will be handled by _process_feedback
+            # This prevents duplicate displays
+
+
 
         elif self.usecase == "Basic Chatbot":
             # Kept exactly as in original code