changed blog generation to HIN orchestrator worker.

need to improve with use of tools for updated data on topics

src/langgraphagenticai/graph/graph_builder.py

@@ -145,73 +145,25 @@ class GraphBuilder:
             graph_builder = StateGraph(state_schema=State)
             blog_node = BlogGenerationNode(self.llm)
             
-            # Modify user_input node to use LLM for structure
-            def user_input_with_validation(state: State) -> dict:
-                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
-
-            # Add nodes with validated user input
-            graph_builder.add_node("user_input", user_input_with_validation)
-            graph_builder.add_node("outline_generator", blog_node.outline_generator)
-            graph_builder.add_node("outline_review", blog_node.outline_review)
-            graph_builder.add_node("draft_generator", blog_node.draft_generator)
-            graph_builder.add_node("draft_review", blog_node.draft_review)
-            graph_builder.add_node("web_search", blog_node.web_search)
+           # # Add nodes
+            graph_builder.add_node("user_input", blog_node.user_input)
+            graph_builder.add_node("orchestrator", blog_node.orchestrator)
+            graph_builder.add_node("llm_call", blog_node.llm_call)
+            graph_builder.add_node("synthesizer", blog_node.synthesizer)
+            graph_builder.add_node("feedback_collector", blog_node.feedback_collector)
             graph_builder.add_node("revision_generator", blog_node.revision_generator)
 
-            # Define edges
+            # Add edges
             graph_builder.add_edge(START, "user_input")
-            graph_builder.add_edge("user_input", "outline_generator")
-            graph_builder.add_edge("outline_generator", "outline_review")
-            
-            # Conditional edge for outline review based on button feedback
-            def determine_outline_review(state):
-                if not state:
-                    logger.error("Invalid state provided")
-                    return "outline_review"
-                feedback = state.get("outline_feedback", "")
-                if not feedback:  # No feedback yet, stay at review
-                    return "outline_review"
-                return "draft_generator" if feedback == "approved" else "outline_generator"
-
-            graph_builder.add_conditional_edges(
-                "outline_review",
-                determine_outline_review,
-                {"outline_review": "outline_review", "outline_generator": "outline_generator", "draft_generator": "draft_generator"}
-            )
-
-            # Draft generator conditional edge for web search
-            graph_builder.add_conditional_edges(
-                "draft_generator",
-                lambda state: "web_search" if state.get("needs_facts", False) else "draft_review",
-                {"web_search": "web_search", "draft_review": "draft_review"}
-            )
-            graph_builder.add_edge("web_search", "draft_generator")
-            
-            # Conditional edge for draft review based on button feedback
-            def determine_draft_review(state):
-                if not state:
-                    logger.error("Invalid state provided")
-                    return "draft_review"
-                feedback = state.get("draft_feedback", "")
-                if not feedback:  # No feedback yet, stay at review
-                    return "draft_review"
-                return END if feedback == "approved" else "revision_generator"
-
-            graph_builder.add_conditional_edges(
-                "draft_review",
-                determine_draft_review,
-                {"draft_review": "draft_review", "revision_generator": "revision_generator", END: END}
-            )
-            graph_builder.add_edge("revision_generator", "draft_review")
+            graph_builder.add_edge("user_input", "orchestrator")
+            graph_builder.add_conditional_edges("orchestrator", lambda state: blog_node.assign_workers(state), ["llm_call"])
+            graph_builder.add_edge("llm_call", "synthesizer")
+            graph_builder.add_edge("synthesizer", "feedback_collector")
+            graph_builder.add_conditional_edges("feedback_collector", blog_node.route_feedback, {"revision_generator": "revision_generator", END: END})
+            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=["outline_review", "draft_review"], checkpointer=self.memory)
+            return graph_builder.compile(interrupt_before=["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,41 +1,41 @@
-# 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
+# # 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
 
+
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class Sections(BaseModel):
-    sections: List[Section] = Field(description="List of sections for the blog report.")
-
 class BlogGenerationNode:
     def __init__(self, model):
         """Initialize the BlogGenerationNode with an LLM."""
-        self.planner = model.with_structured_output(Sections)
         self.llm = model
-        tools = get_tools(max_results=3)
-        self.search_tool = tools[0] if tools else None
-        if not self.search_tool:
-            logger.warning("No search tool available; web search will be skipped.")
-        self.draft_prompt = ChatPromptTemplate.from_messages([
-            ("system", "You are a blog writer. Generate a section starting with a markdown heading (##) matching the section name. "
-                       "Use the provided description and web search results to guide the content. Use markdown formatting (e.g., paragraphs, lists). "
-                       "Focus only on the current section and avoid repeating prior content unless directly relevant. "
-                       "Web search results: {search_results}"),
-            ("human", "Section name: {name}\nDescription: {description}")
-        ])
-        self.feedback_prompt = ChatPromptTemplate.from_messages([
-            ("system", "Refine the blog sections based on feedback: {feedback}. Keep prior content and adjust as requested."),
-            ("placeholder", "{messages}")
-        ])
+        self.planner = model.with_structured_output(Sections)
+
 
     def user_input(self, state: State) -> dict:
         """Handle user input (Node A)."""
@@ -57,202 +57,95 @@ class BlogGenerationNode:
         logger.info(f"Parsed requirements: {result}")
         return result
 
-    def outline_generator(self, state: State) -> dict:
-        """Generate the blog outline based on user requirements (Node B)."""
-        logger.info(f"Executing outline_generator with state: {state}")
-        topic = state.get("topic", "No topic provided")
-        objective = state.get("objective", "Informative")
-        target_audience = state.get("target_audience", "General Audience")
-        tone_style = state.get("tone_style", "Casual")
-        word_count = state.get("word_count", 1000)
-        structure = state.get("structure", "Introduction, Main Points, Conclusion")
 
-        structure_list = [s.strip() for s in structure.split(",")]
+    def orchestrator(self,state: State) -> dict:
+        """Orchestrator that generates a plan for the report."""
+        logger.info(f"Executing orchestrator with state: {state}")
+        structure_list = [s.strip() for s in state["structure"].split(",")]
         section_count = len(structure_list)
-
+        
         prompt = (
-            f"Generate a structured plan for a blog report with exactly {section_count} sections, using clear section headings (e.g., ## Heading). "
-            f"Ensure the content is relevant to the topic: {topic}. "
-            f"The blog's objective is {objective}, aimed at {target_audience}, with a {tone_style} tone. "
-            f"Target a word count of {word_count} words. "
-            f"Use this exact structure and section names: {', '.join(structure_list)}. Do not add extra sections or change the names."
-            f"\nReturn the result as a JSON object with a 'sections' key, where each section has 'name' and 'description' fields."
+            f"Generate a structured plan for a blog report with exactly {section_count} sections. "
+            f"Ensure the content is relevant to the topic: {state['topic']}. "
+            f"The blog's objective is {state['objective']}, aimed at {state['target_audience']}, "
+            f"with a {state['tone_style']} tone. Target a word count of {state['word_count']} words. "
+            f"Use this exact structure and section names: {', '.join(structure_list)}. "
+            f"Do not add extra sections or change the names."
         )
-        messages = [
+        report_sections = self.planner.invoke([
             SystemMessage(content=prompt),
-            HumanMessage(content=f"Topic: {topic}")
-        ]
-        logger.info(f"Outline generator input messages: {messages}")
-        try:
-            logger.info("Invoking LLM for outline generation")
-            report_sections = self.planner.invoke(messages)
-            logger.info(f"Raw LLM output: {report_sections}")
-
-            # Handle various LLM output formats
-            if isinstance(report_sections, list):
-                sections = [Section(name=s["name"], description=s["description"]) for s in report_sections]
-                report_sections = Sections(sections=sections)
-            elif isinstance(report_sections, dict):
-                if "sections" in report_sections:
-                    sections = [Section(name=s["name"], description=s["description"]) 
-                               for s in report_sections["sections"]]
-                    report_sections = Sections(sections=sections)
-            
-            # Create formatted outline text with clear section
-            outline = "\n".join([f"- **{s['name']}**: {s['description']}" for s in report_sections.sections])
-            outline_message = f"Generated outline:\n{outline}\n\nPlease review the outline above."
-            
-            # Ensure both sections and messages are properly set in state
-            state["messages"].append(AIMessage(content=outline_message))
-            state["sections"] = report_sections.sections
-            
-            # Return both sections and messages in the result
-            return {
-                "sections": report_sections.sections,
-                "messages": state["messages"]
-            }
-
-        except Exception as e:
-            logger.error(f"LLM invocation failed: {e}")
-            state["messages"].append(AIMessage(content=f"Error generating outline: {e}"))
-            return {"sections": [], "messages": state["messages"]}
-
-    def outline_review(self, state: State) -> dict:
-        """Handle human review of the outline (Outline Review-Human, Node C)."""
-        logger.info(f"Executing outline_review with state: {state}")
-        feedback = st.session_state.get("outline_feedback", "")
-        state["outline_feedback"] = feedback  # Sync feedback from Streamlit state
-        logger.info(f"Outline feedback set: {feedback}")
-        return {"outline_approved": feedback == "approved", "outline_feedback": feedback}
-
-    def web_search(self, state: State) -> dict:
-        """Fetch web search results for each section (Web Search/Scraping, Node I)."""
-        logger.info(f"Executing web_search with state: {state}")
-        search_results = {}
-        if not self.search_tool:
-            logger.info("No search tool available; skipping web search.")
-            return {"search_results": {s['name']: "No search tool configured." for s in state["sections"]}}
-        for section in state["sections"]:
-            query = f"{state['topic']} {section['name']}"
-            logger.info(f"Searching for: {query}")
-            try:
-                results = self.search_tool.invoke({"query": query})
-                search_results[section['name']] = "\n".join([r.get("content", "") for r in results])
-            except Exception as e:
-                logger.error(f"Web search failed for {query}: {e}")
-                search_results[section['name']] = "No data available due to search error."
-        logger.info(f"Search results: {search_results}")
-        return {"search_results": search_results}
-
-    def draft_generator(self, state: State) -> dict:
-        """Generate the initial draft using search results (Draft Generator-LLM, Node D)."""
-        logger.info(f"Executing draft_generator with state: {state}")
-        if not state.get("search_results"):
-            logger.info("No search results found, triggering web search.")
-            return {"needs_facts": True}
+            HumanMessage(content=f"Topic: {state['topic']}")
+        ])
+        logger.info(f"Report Sections: {report_sections}")
+        return {"sections": report_sections.sections}
+
+    def llm_call(self,state: WorkerState) -> dict:
+        """Worker writes a section of the report."""
+        section = self.llm.invoke([
+            SystemMessage(content="Write a report section following the provided name and description. Include no preamble for each section. Use markdown formatting."),
+            HumanMessage(content=f"Here is the section name: {state['section'].name} and description: {state['section'].description}")
+        ])
+        return {"completed_sections": [section.content]}
+
+    def synthesizer(self,state: State) -> dict:
+        """Synthesize full report from sections."""
+        completed_sections = state["completed_sections"]
+        final_report = "\n\n---\n\n".join(completed_sections)
+        logger.info(f"Synthesized report: {final_report}")
+        return {"final_report": final_report}
+
+    def feedback_collector(self, state: State) -> dict:
+        """Collect human feedback on the draft using Streamlit interface."""
+        logger.info("Executing feedback_collector")
         
-        completed_sections = []
-        final_draft = []
+        # Get feedback from Streamlit session state
+        feedback = st.session_state.get("draft_feedback", "")
         
-        # Format each section with consistent styling
-        for section in state["sections"]:
-            prompt_inputs = {
-                "name": section['name'],
-                "description": section['description'],
-                "search_results": state["search_results"].get(section['name'], "No data")
+        # 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"]
             }
-            messages = self.draft_prompt.format_messages(**prompt_inputs)
-            logger.info(f"Draft prompt messages: {messages}")
-            try:
-                content = self.llm.invoke(messages).content
-                # Ensure consistent section formatting
-                section_content = self._format_section_content(section['name'], content)
-                completed_sections.append(section_content)
-                final_draft.append(section_content)
-            except Exception as e:
-                logger.error(f"Failed to generate section {section['name']}: {e}")
-                error_content = f"## {section['name']}\nError: {e}"
-                completed_sections.append(error_content)
-                final_draft.append(error_content)
-        
-        # Join sections with clear separation and formatting
-        draft = "\n\n".join(final_draft)
-        
-        # Create a formatted display version with consistent styling
-        display_content = self._format_display_content(draft)
-        
-        # Update state
-        state["completed_sections"] = completed_sections
-        state["messages"].append(AIMessage(content=display_content))
-        
-        logger.info(f"Generated draft with {len(completed_sections)} sections")
-        return {
-            "completed_sections": completed_sections,
-            "draft_content": draft,
-            "needs_facts": False
-        }
 
-    def _format_section_content(self, section_name: str, content: str) -> str:
-        """Format a single section with consistent styling."""
-        # Clean up the content
-        content = content.strip()
-        
-        # Ensure section starts with proper heading
-        if not content.startswith(f"## {section_name}"):
-            content = f"## {section_name}\n\n{content}"
+    def revision_generator(self,state: State) -> dict:
+        """Revise the report based on human feedback."""
+        if state["draft_approved"]:
+            return {"final_report": state["final_report"]}  # No revision needed
         
-        # Format paragraphs with proper spacing
-        paragraphs = content.split("\n\n")
-        formatted_paragraphs = []
+        feedback = state["feedback"]
+        completed_sections = state["completed_sections"]
+        revised_sections = []
         
-        for para in paragraphs:
-            # Clean up paragraph
-            para = para.strip()
-            if para.startswith("#"):  # It's a heading
-                formatted_paragraphs.append(para)
-            else:  # It's a regular paragraph
-                formatted_paragraphs.append(para)
+        for section in completed_sections:
+            revised_content = self.llm.invoke([
+                SystemMessage(content=f"Refine this section based on feedback: {feedback}. Keep prior content and adjust as requested. Use markdown formatting."),
+                HumanMessage(content=section)
+            ])
+            revised_sections.append(revised_content.content)
         
-        return "\n\n".join(formatted_paragraphs)
-
-    def _format_display_content(self, draft: str) -> str:
-        """Format the complete draft for display."""
-        return (
-            "# Generated Blog Draft\n\n"
-            f"{draft}\n\n"
-            "---\n\n"
-            "Please review the draft with the buttons below."
-        )
-
-    def draft_review(self, state: State) -> dict:
-        """Handle human review of the draft (Draft Review-Human, Node E)."""
-        logger.info(f"Executing draft_review with state: {state}")
-        feedback = st.session_state.get("draft_feedback", "")
-        state["draft_feedback"] = feedback  # Sync feedback from Streamlit state
-        logger.info(f"Draft feedback set: {feedback}")
-        if feedback == "approved":
-            final_draft = "\n\n---\n\n".join(state["completed_sections"])
-            state["messages"].append(AIMessage(content=f"Final approved draft:\n{final_draft}"))
-            logger.info(f"Updated state with final draft: {state}")
-        return {"draft_approved": feedback == "approved", "feedback": feedback}
-
-    def revision_generator(self, state: State) -> dict:
-        """Refine the draft based on human feedback (Revision Generator-LLM, Node F)."""
-        logger.info(f"Executing revision_generator with state: {state}")
-        feedback = state.get("feedback", "")
-        prompt_inputs = {
-            "feedback": feedback,
-            "messages": state["messages"]
-        }
-        messages = self.feedback_prompt.format_messages(**prompt_inputs)
-        logger.info(f"Feedback prompt messages: {messages}")
-        try:
-            refined = self.llm.invoke(messages).content.split("\n\n---\n\n")
-            draft = "\n\n---\n\n".join(refined)
-            state["messages"].append(AIMessage(content=f"Refined draft:\n{draft}\nPlease review again with the buttons below."))
-            logger.info(f"Updated state with refined draft: {state}")
-            return {"completed_sections": refined, "feedback": feedback}
-        except Exception as e:
-            logger.error(f"Failed to refine draft: {e}")
-            state["messages"].append(AIMessage(content=f"Error refining draft: {e}"))
-            return {"completed_sections": state["completed_sections"], "feedback": feedback}
+        logger.info(f"Revised sections: {revised_sections}")
+        return {"completed_sections": revised_sections}
+
+    # Conditional edge function to create llm_call workers
+    def assign_workers(self,state: State):
+        """Assign a worker to each section in the plan."""
+        return [Send("llm_call", {"section": s}) for s in state["sections"]]
+
+    # Conditional edge for feedback loop
+    def route_feedback(self,state: State):
+        """Route based on whether draft is approved."""
+        if state["draft_approved"]:
+            return END
+        return "revision_generator"

src/langgraphagenticai/state/state.py

@@ -1,29 +1,34 @@
-# src/langgraphagenticai/state/state.py
-from typing import TypedDict, List, Dict, Annotated, Literal, Optional
-from langchain_core.messages import BaseMessage
+from typing import Annotated, List, TypedDict
+import operator
+from pydantic import BaseModel, Field
 from langgraph.graph.message import add_messages
 
-class Section(TypedDict):
-    """Represents a single section of the blog."""
-    name: str
-    description: str
+# Schema for structured output to use in planning
+class Section(BaseModel):
+    name: str = Field(description="Name for this section of the report.")
+    description: str = Field(description="Brief overview of the main topics and concepts to be covered in this section.")
+
+class Sections(BaseModel):
+    sections: List[Section] = Field(description="Sections of the report.")
+
+# Graph state
+class State(TypedDict):
 
-class State(TypedDict, total=False):
-    """State schema for the LangGraph workflow, with all fields optional."""
     messages: Annotated[list, add_messages] # Chat history including user inputs and AI responses
 
-    topic: str  # Blog topic from user input
-    objective: str  # Blog objective (e.g., Informative, Persuasive)
-    target_audience: str  # Intended audience (e.g., General Audience)
-    tone_style: str  # Tone and style (e.g., Casual, Formal)
-    word_count: int  # Target word count for the blog
-    structure: str  # Blog structure (e.g., "Introduction, Main Points, Conclusion")
-    sections: List[Section]  # List of blog sections with names and descriptions
-    search_results: Dict[str, str]  # Web search results keyed by section name
-    completed_sections: List[str]  # Generated sections of the draft
-    needs_facts: bool  # Flag to trigger web search
-    outline_feedback: str  # Feedback from outline review ("approved" or "add_more_details")
-    draft_feedback: str  # Feedback from draft review ("approved" or "add_more_details")
-    outline_approved: bool  # Approval status of the outline
-    draft_approved: bool  # Approval status of the draft
-    feedback: str  # General feedback string for revisions
+    topic: str  # Report topic from user input
+    objective: str  # Objective from user input
+    target_audience: str  # Target audience from user input
+    tone_style: str  # Tone/style from user input
+    word_count: int  # Word count from user input
+    structure: str  # Structure from user input
+    sections: List[Section]  # List of report sections
+    completed_sections: Annotated[List[str], operator.add]  # All workers write to this key in parallel
+    final_report: str  # Final report
+    feedback: str  # Human feedback
+    draft_approved: bool  # Whether the draft is approved
+
+# Worker state
+class WorkerState(TypedDict):
+    section: Section
+    completed_sections: Annotated[List[str], operator.add]

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -1,6 +1,7 @@
 import streamlit as st
 from langchain_core.messages import HumanMessage, AIMessage
 import logging
+import json
 
 logger = logging.getLogger(__name__)
 
@@ -19,8 +20,7 @@ class DisplayResultStreamlit:
         defaults = {
             "waiting_for_feedback": False,
             "blog_requirements_collected": False,
-            "outline_displayed": False,
-            "draft_displayed": False,
+            "content_displayed": False,
             "graph_state": None,
             "current_session_id": None
         }
@@ -36,8 +36,7 @@ class DisplayResultStreamlit:
             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.content_displayed = False
             st.session_state.current_session_id = session_id
         return store[session_id]
 
@@ -56,11 +55,11 @@ class DisplayResultStreamlit:
             self._handle_chatbot_input()
 
     def _handle_blog_generation(self):
-        # Fallback: Check graph state if waiting_for_feedback isn't set
+        # Check if we're waiting for feedback
         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")
+            if graph_state.next and graph_state.next[0] == "feedback_collector":
+                logger.info("Setting waiting_for_feedback based on graph state")
                 st.session_state.waiting_for_feedback = True
 
         if st.session_state.waiting_for_feedback:
@@ -88,69 +87,71 @@ class DisplayResultStreamlit:
             submit_button = st.form_submit_button("Submit Blog Requirements")
 
             if submit_button:
-                if not all([topic, objective, target_audience, tone_style, structure]):
+                if not all([topic, objective, target_audience, tone_style]):
                     st.error("Please fill in all required fields.")
                     return
-                user_message = f"Topic: {topic} Objective: {objective} Target Audience: {target_audience} Tone & Style: {tone_style} Word Count: {word_count} Structure: {structure}"
+                user_message = f"Topic: {topic}\nObjective: {objective}\nTarget Audience: {target_audience}\nTone & Style: {tone_style}\nWord Count: {word_count}\nStructure: {structure}"
                 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.content_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):
+        
+        # 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):
             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"])
-                st.markdown("### Generated Draft")
-                st.markdown(draft_content)
-                st.session_state.draft_displayed = True
+                st.markdown("### Generated Blog Content")
+                st.markdown(self._format_blog_content(latest_state["blog_content"]))
+                st.session_state.content_displayed = True
 
+        # 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 == "outline_review":
-            st.write("Review the outline:")
-            col1, col2 = st.columns(2)
-            with col1:
-                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:")
+        
+        if current_node == "feedback_collector":
+            st.write("### Review the generated content:")
             col1, col2 = st.columns(2)
+            
             with col1:
-                if st.button("Looks good", key="draft_approve"):
-                    st.session_state.draft_feedback = "approved"
-                    st.session_state.waiting_for_feedback = False
-                    st.session_state.draft_displayed = False
-                    logger.info("Draft approved")
+                if st.button("Approve", key="content_approve"):
+                    feedback = {
+                        "approved": True,
+                        "comments": "Content approved."
+                    }
+                    self._submit_feedback(feedback)
+                    
             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()
+                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)
+
+    def _submit_feedback(self, feedback):
+        """Submit feedback to the graph and continue processing."""
+        try:
+            # Convert feedback to the expected ReviewFeedback format
+            feedback_json = json.dumps(feedback)
+            st.session_state.waiting_for_feedback = False
+            st.session_state.content_displayed = False
+            # Continue processing with the feedback
+            self._process_graph_stream(HumanMessage(content=feedback_json))
+            logger.info(f"Feedback submitted: {feedback}")
+        except Exception as e:
+            logger.error(f"Error submitting feedback: {e}")
+            st.error(f"Error submitting feedback: {e}")
 
     def _handle_chatbot_input(self):
         user_message = st.chat_input("Enter your message:")
@@ -171,18 +172,19 @@ class DisplayResultStreamlit:
                             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"]:
+                    
+                    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(f"Paused at {graph_state.next[0]} for feedback")
+                        logger.info("Paused for feedback collection")
                         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
+                        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"):
@@ -197,23 +199,24 @@ class DisplayResultStreamlit:
     def _display_result(self, response):
         logger.info(f"Display result response: {response}")
         if self.usecase == "Blog Generation":
-            # Outline display moved to _process_feedback
             messages = response.get("messages", [])
             if messages:
                 content = messages[-1].content
-                if "# Generated Blog Draft" in content and not st.session_state.get("draft_displayed", False):
-                    st.markdown(self._format_blog_content(content))
-                    st.session_state.draft_displayed = True
-                elif "Final approved draft:" in content:
-                    st.markdown("### Final Draft")
-                    st.markdown(self._format_blog_content(content.split("Final approved draft:", 1)[1]))
-                elif not any(x in content for x in ["Generated outline:", "# Generated Blog Draft", "Final approved draft:"]):
+                blog_content = response.get("blog_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)
 
         elif self.usecase == "Basic Chatbot":
+            # Kept exactly as in original code
             st.markdown(response.get("messages", [{}])[-1].content)
 
         elif self.usecase == "Chatbot with Tool":
+            # Kept exactly as in original code
             content = response.get("messages", [{}])[-1].content
             tool_output = response.get("tool_output", "")
             if tool_output:
@@ -221,14 +224,11 @@ class DisplayResultStreamlit:
                 st.code(tool_output, language="text")
             st.markdown(content)
 
-        elif self.usecase == "Coding Peer Review":
-            st.markdown("### Code Review Feedback")
-            st.markdown(response.get("review_output", "No review generated."))
-            if corrected_code := response.get("corrected_code", ""):
-                st.markdown("### Corrected Code")
-                st.code(corrected_code, language="python")
-
     def _format_blog_content(self, content):
+        """Format blog content for better display in Streamlit."""
+        if not content:
+            return ""
+            
         sections = content.strip().split("\n\n")
         formatted = "\n\n".join(
             f"\n\n{s.strip()}" if s.startswith("#") else s.strip()