cleaned main.py Remove obsolete langgraph API files and clean up related configurations

langgraph.json

@@ -1,7 +0,0 @@
-{
-    "dependencies": ["."],
-    "graphs": {
-        "main_graph": "C:\\Users\\kamal\\OneDrive\\Desktop\\Research\\krish\\Projects\\LangGraphProject\\src\\langgraphagenticai\\graph\\graph_builder.py:graph"
-    },
-    "env": "../.env"
-}

src/langgraphagenticai/main.py

@@ -1,18 +1,17 @@
-# src/langgraphagenticai/main.py
 import streamlit as st
 import uuid
 import logging
 import os
-from langchain_core.messages import HumanMessage, AIMessage
+from langchain_core.messages import HumanMessage
 from langchain_community.chat_message_histories import ChatMessageHistory
 from langchain_core.chat_history import BaseChatMessageHistory
 from langchain_core.runnables.history import RunnableWithMessageHistory
 from src.langgraphagenticai.ui.streamlitui.loadui import LoadStreamlitUI
-from src.langgraphagenticai.ui.streamlitui.display_result import DisplayResultStreamlit
 from src.langgraphagenticai.LLMS.groqllm import GroqLLM
 from src.langgraphagenticai.LLMS.geminillm import GoogleLLM
 from src.langgraphagenticai.LLMS.chatgptllm import OpenaiLLM
 from src.langgraphagenticai.graph.graph_builder import GraphBuilder
+from src.langgraphagenticai.ui.streamlitui.display_result import DisplayResultStreamlit
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -25,9 +24,12 @@ def get_session_history(session_id: str) -> BaseChatMessageHistory:
     return store[session_id]
 
 def load_langgraph_agenticai_app():
+    """
+    Loads and runs the LangGraph AgenticAI application with Streamlit UI.
+    Initializes UI, configures LLM, sets up graph, and manages session state.
+    """
     ui = LoadStreamlitUI()
     user_controls = ui.load_streamlit_ui()
-    display_result = DisplayResultStreamlit()
 
     if not user_controls:
         st.error("Error: Failed to load user controls from the UI.")
@@ -55,6 +57,7 @@ def load_langgraph_agenticai_app():
         st.warning("Please enter your OpenAI API key in the sidebar.")
         return
 
+    # Session state initialization
     if "session_id" not in st.session_state:
         st.session_state.session_id = str(uuid.uuid4())
     if "thread_id" not in st.session_state:
@@ -67,43 +70,11 @@ def load_langgraph_agenticai_app():
         st.session_state.blog_requirements_collected = False
     if "current_usecase" not in st.session_state:
         st.session_state.current_usecase = None
-    if "outline_feedback" not in st.session_state:
-        st.session_state.outline_feedback = None
-    if "draft_feedback" not in st.session_state:
-        st.session_state.draft_feedback = None
-    if "draft_displayed" not in st.session_state:
-        st.session_state.draft_displayed = False
-    if "outline_displayed" not in st.session_state:
-        st.session_state.outline_displayed = False
 
     config = {"configurable": {"session_id": st.session_state.session_id, "thread_id": st.session_state.thread_id, "recursion_limit": 50}}
     logger.info(f"Session ID: {st.session_state.session_id}, Thread ID: {st.session_state.thread_id}")
 
-    st.markdown("### Chat")
-    session_history = get_session_history(st.session_state.session_id)
-    for message in session_history.messages:
-        role = "user" if isinstance(message, HumanMessage) else "assistant"
-        with st.chat_message(role):
-            st.markdown(message.content, unsafe_allow_html=True)
-
-    usecase = user_controls.get("selected_usecase")
-    if not usecase:
-        st.error("Error: No use case selected.")
-        return
-
-    if st.session_state.current_usecase != usecase:
-        logger.info(f"Use case changed to: {usecase}. Resetting session state.")
-        st.session_state.waiting_for_feedback = False
-        st.session_state.blog_requirements_collected = False
-        st.session_state.current_usecase = usecase
-        st.session_state.draft_displayed = False
-        st.session_state.outline_displayed = False
-        session_history.clear()
-        if "graph" in st.session_state:
-            del st.session_state.graph
-        if "with_message_history" in st.session_state:
-            del st.session_state.with_message_history
-
+    # Load LLM
     try:
         if selected_llm == "Groq":
             llm_config = GroqLLM(user_controls_input=user_controls)
@@ -120,6 +91,23 @@ def load_langgraph_agenticai_app():
             st.error("Error: LLM model could not be initialized.")
             return
 
+        # Graph setup
+        usecase = user_controls.get("selected_usecase")
+        if not usecase:
+            st.error("Error: No use case selected.")
+            return
+
+        if st.session_state.current_usecase != usecase:
+            logger.info(f"Use case changed to: {usecase}. Resetting session state.")
+            st.session_state.waiting_for_feedback = False
+            st.session_state.blog_requirements_collected = False
+            st.session_state.current_usecase = usecase
+            get_session_history(st.session_state.session_id).clear()
+            if "graph" in st.session_state:
+                del st.session_state.graph
+            if "with_message_history" in st.session_state:
+                del st.session_state.with_message_history
+
         if "graph" not in st.session_state:
             graph_builder = GraphBuilder(model)
             graph = graph_builder.setup_graph(usecase)
@@ -131,188 +119,15 @@ def load_langgraph_agenticai_app():
             )
             st.session_state.graph = graph
             st.session_state.with_message_history = with_message_history
-        if not st.session_state.graph:
-            raise ValueError("Graph initialization failed")
 
-    except Exception as e:
-        logger.error(f"Error initializing graph: {e}")
-        st.error(f"Failed to initialize graph: {e}. Please check your configuration and try again.")
-        return
-
-    if usecase == "Blog Generation":
-        if st.session_state.waiting_for_feedback:
-            if st.session_state.graph_state:
-                latest_state = st.session_state.graph_state.values
-                
-                # Display draft content only if not already displayed
-                if "completed_sections" in latest_state and not st.session_state.get("draft_displayed"):
-                    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
-                        display_result.display_result(latest_state, usecase)
-
-            # Determine which review stage we're in
-            current_node = st.session_state.graph_state.next[0] if st.session_state.graph_state.next else None
-            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
-                        st.session_state.outline_displayed = False  # Reset for next stage
-                        logger.info("Outline approved via button")
-                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 rejected via button, requesting more details")
-            elif current_node == "draft_review":
-                st.write("Review the draft:")
-                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  # Reset display flag
-                        logger.info("Draft approved via button")
-                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  # Reset display flag
-                        logger.info("Draft rejected via button, requesting more details")
-
-            # Process feedback if provided
-            if not st.session_state.waiting_for_feedback:
-                graph = st.session_state.get("graph")
-                if not graph:
-                    logger.error("Graph not initialized in session state")
-                    st.error("Error: Workflow graph not initialized.")
-                    return
-                with st.spinner("Processing feedback..."):
-                    for event in graph.stream(None, config=config):
-                        logger.info(f"Graph event: {event}")
-                        for node, state in event.items():
-                            # Update state handling for outline display
-                            if "messages" in state and state["messages"]:
-                                with st.chat_message("assistant"):
-                                    if "sections" in state:
-                                        # Force outline display when sections are available
-                                        display_result.display_result({
-                                            "sections": state["sections"],
-                                            "messages": state["messages"]
-                                        }, usecase)
-                                    else:
-                                        display_result.display_result(state, usecase)
-                                session_history.add_ai_message(state["messages"][-1].content)
-                        graph_state = graph.get_state(config)
-                        logger.info(f"Graph state after event: {graph_state}")
-                        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"Graph paused at: {graph_state.next}")
-                            break
-                        elif not graph_state.next:
-                            logger.info("Blog generation completed")
-                            st.session_state.blog_requirements_collected = False
-                            with st.chat_message("assistant"):
-                                st.markdown("✅ Blog generation completed!")
-                            if st.button("New Blog Generation", key="new_blog_button"):
-                                logger.info("Starting new blog generation")
-                                session_history.clear()
-                                st.session_state.graph_state = None
-                                st.session_state.waiting_for_feedback = False
-                                st.session_state.outline_feedback = None
-                                st.session_state.draft_feedback = None
-                                st.rerun()
-                            break
-
-        elif not st.session_state.blog_requirements_collected:
-            st.markdown("### Blog Requirements")
-            with st.form("blog_requirements_form"):
-                topic = st.text_input("Topic", placeholder="e.g., The Future of AI in Healthcare")
-                objective = st.radio("Objective", ["Informative", "Persuasive", "Storytelling", "Other"])
-                if objective == "Other":
-                    objective = st.text_input("Specify Objective", placeholder="Enter custom objective")
-                target_audience = st.radio("Target Audience", ["Beginners", "Experts", "General Audience", "Other"])
-                if target_audience == "Other":
-                    target_audience = st.text_input("Specify Target Audience", placeholder="Enter custom audience")
-                tone_style = st.radio("Tone & Style", ["Formal", "Casual", "Technical", "Engaging", "Other"])
-                if tone_style == "Other":
-                    tone_style = st.text_input("Specify Tone & Style", placeholder="Enter custom tone and style")
-                word_count = st.number_input("Word Count", min_value=100, max_value=5000, value=1000, step=100)
-                structure = st.text_area("Structure", placeholder="e.g., Introduction, Key Points, Conclusion")
-                submit_button = st.form_submit_button("Submit Blog Requirements")
-
-            if submit_button:
-                if not topic or not objective or not target_audience or not tone_style or not structure:
-                    st.error("Please fill in all required fields.")
-                    return
-                
-                # Format user input as a single line
-                user_message = f"Topic: {topic} Objective: {objective} Target Audience: {target_audience} Tone & Style: {tone_style} Word Count: {word_count} Structure: {structure}"
-                
-                logger.info(f"Blog requirements submitted: {user_message}")
-                session_history.add_user_message(user_message)
-                with st.chat_message("user"):
-                    st.markdown(user_message)
-                st.session_state.blog_requirements_collected = True
+        # Display chat history and process input
+        display = DisplayResultStreamlit(st.session_state.graph, st.session_state.with_message_history, config, usecase)
+        display.display_chat_history()
+        display.process_user_input()
 
-                with st.spinner("Generating outline..."):
-                    input_data = {"messages": [HumanMessage(content=user_message)]}
-                    graph = st.session_state.graph
-                    if not graph:
-                        logger.error("Graph not initialized before streaming initial input")
-                        st.error("Error: Workflow graph not initialized.")
-                        return
-                    for event in graph.stream(input_data, config=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"):
-                                    display_result.display_result(state, usecase)
-                                session_history.add_ai_message(state["messages"][-1].content)
-                        graph_state = graph.get_state(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
-                    st.rerun()
-
-        # Initialize session state for draft display tracking
-        if "draft_displayed" not in st.session_state:
-            st.session_state.draft_displayed = False
-
-    else:
-        user_message = st.chat_input("Enter your message:")
-        if user_message:
-            try:
-                logger.info(f"User message: {user_message}")
-                session_history.add_user_message(user_message)
-                with st.chat_message("user"):
-                    st.markdown(user_message, unsafe_allow_html=True)
-
-                with st.spinner("Processing..."):
-                    input_data = {"messages": [HumanMessage(content=user_message)]}
-                    logger.info(f"Streaming graph with input: {input_data}")
-                    for event in st.session_state.with_message_history.stream(input_data, config=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"):
-                                    display_result.display_result(state, usecase)
-                                session_history.add_ai_message(state["messages"][-1].content)
-                        graph_state = st.session_state.graph.get_state(config)
-                        logger.info(f"Graph state after event: {graph_state}")
-                        if not graph_state.next:
-                            logger.info("Graph completed execution")
-                            break
-            except Exception as e:
-                logger.error(f"Error occurred: {e}")
-                st.error(f"Error occurred: {e}")
+    except Exception as e:
+        logger.error(f"Error initializing application: {e}")
+        st.error(f"Failed to initialize application: {e}")
 
 if __name__ == "__main__":
     load_langgraph_agenticai_app()

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -1,101 +1,183 @@
 import streamlit as st
+from langchain_core.messages import HumanMessage, AIMessage
 
 class DisplayResultStreamlit:
-    def display_result(self, response: dict, usecase: str) -> str:
-        if usecase == "Blog Generation":
-            # Always prioritize direct sections display
-            if "sections" in response:
-                sections = response.get("sections", [])
-                if sections and not st.session_state.get("outline_displayed", False):
-                    outline_text = "### Generated Outline\n\n"
-                    for section in sections:
-                        outline_text += f"**{section['name']}**: {section['description']}\n\n"
-                    st.markdown(outline_text)
-                    st.markdown("Please review the outline above.")
-                    st.session_state.outline_displayed = True
-                    return outline_text
-
-            # Process message-based content
-            messages = response.get("messages", [])
-            if not messages:
-                return "No response generated."
-            
-            assistant_response = messages[-1].content if messages else "No response generated."
-            
-            # Check for draft content with improved formatting
-            if "# Generated Blog Draft" in assistant_response and not st.session_state.get("draft_displayed", False):
-                formatted_content = self._format_blog_content(assistant_response)
-                st.markdown(formatted_content)
+    def __init__(self, graph, with_message_history, config, usecase):
+        self.graph = graph
+        self.with_message_history = with_message_history
+        self.config = config
+        self.usecase = usecase
+        self.session_history = self._get_session_history()
+
+    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()
+        return store[session_id]
+
+    def display_chat_history(self):
+        """Display the chat history from the session."""
+        for message in self.session_history.messages:
+            role = "user" if isinstance(message, HumanMessage) else "assistant"
+            with st.chat_message(role):
+                st.markdown(message.content, unsafe_allow_html=True)
+
+    def process_user_input(self):
+        """Process user input and display results based on the use case."""
+        if self.usecase == "Blog Generation":
+            self._handle_blog_generation()
+        else:
+            self._handle_chatbot_input()
+
+    def _handle_blog_generation(self):
+        if st.session_state.waiting_for_feedback:
+            self._process_feedback()
+        elif not st.session_state.blog_requirements_collected:
+            self._collect_blog_requirements()
+        else:
+            self._process_graph_stream()
+
+    def _collect_blog_requirements(self):
+        st.markdown("### Blog Requirements")
+        with st.form("blog_requirements_form"):
+            topic = st.text_input("Topic", placeholder="e.g., The Future of AI in Healthcare")
+            objective = st.radio("Objective", ["Informative", "Persuasive", "Storytelling", "Other"])
+            if objective == "Other":
+                objective = st.text_input("Specify Objective", placeholder="Enter custom objective")
+            target_audience = st.radio("Target Audience", ["Beginners", "Experts", "General Audience", "Other"])
+            if target_audience == "Other":
+                target_audience = st.text_input("Specify Target Audience", placeholder="Enter custom audience")
+            tone_style = st.radio("Tone & Style", ["Formal", "Casual", "Technical", "Engaging", "Other"])
+            if tone_style == "Other":
+                tone_style = st.text_input("Specify Tone & Style", placeholder="Enter custom tone and style")
+            word_count = st.number_input("Word Count", min_value=100, max_value=5000, value=1000, step=100)
+            structure = st.text_area("Structure", placeholder="e.g., Introduction, Key Points, Conclusion")
+            submit_button = st.form_submit_button("Submit Blog Requirements")
+
+            if submit_button:
+                if not all([topic, objective, target_audience, tone_style, structure]):
+                    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}"
+                self.session_history.add_user_message(user_message)
+                with st.chat_message("user"):
+                    st.markdown(user_message)
+                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 {}
+        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
-            # Check for final draft
-            elif "Final approved draft:" in assistant_response:
-                st.markdown("### Final Draft")
-                final_content = assistant_response.split("Final approved draft:", 1)[1]
-                formatted_final = self._format_blog_content(final_content)
-                st.markdown(formatted_final)
-            # Display other messages without repetition
-            elif not any(x in assistant_response for x in ["Generated outline:", "# Generated Blog Draft", "Final approved draft:"]):
-                st.markdown(assistant_response)
-            
-            return assistant_response
-
-        elif usecase == "Basic Chatbot":
-            assistant_response = response.get("messages", [{}])[-1].content if response.get("messages") else "No response generated."
-            st.markdown(assistant_response)
-            return assistant_response
-
-        elif usecase == "Chatbot with Tool":
-            if "messages" in response:
-                assistant_response = response.get("messages", [{}])[-1].content
-                tool_output = response.get("tool_output", "")
-                if tool_output:
-                    st.markdown("**Tool Output:**")
-                    st.code(tool_output, language="text")
-                st.markdown(assistant_response)
-                return assistant_response
-            return "No response generated."
-
-        elif usecase == "Coding Peer Review":
-            review_output = response.get("review_output", "No review generated.")
-            corrected_code = response.get("corrected_code", "")
+
+        current_node = st.session_state.graph_state.next[0] if st.session_state.graph_state.next else None
+        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
+            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
+        elif current_node == "draft_review":
+            st.write("Review the draft:")
+            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
+            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
+
+        if not st.session_state.waiting_for_feedback:
+            self._process_graph_stream()
+
+    def _handle_chatbot_input(self):
+        user_message = st.chat_input("Enter your message:")
+        if user_message:
+            self.session_history.add_user_message(user_message)
+            with st.chat_message("user"):
+                st.markdown(user_message, unsafe_allow_html=True)
+            self._process_graph_stream(HumanMessage(content=user_message))
+
+    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"]:
+                        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()
+
+    def _display_result(self, 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
+            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:"]):
+                    st.markdown(content)
+
+        elif self.usecase == "Basic Chatbot":
+            st.markdown(response.get("messages", [{}])[-1].content)
+
+        elif self.usecase == "Chatbot with Tool":
+            content = response.get("messages", [{}])[-1].content
+            tool_output = response.get("tool_output", "")
+            if tool_output:
+                st.markdown("**Tool Output:**")
+                st.code(tool_output, language="text")
+            st.markdown(content)
+
+        elif self.usecase == "Coding Peer Review":
             st.markdown("### Code Review Feedback")
-            st.markdown(review_output)
-            if corrected_code:
+            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")
-            return review_output
 
-        else:
-            st.error(f"Unknown use case: {usecase}")
-            return ""
-
-    def _format_blog_content(self, content: str) -> str:
-        """Format blog content with consistent styling and spacing."""
-        # Split content into sections
-        sections = content.split("\n\n")
-        formatted_sections = []
-        
-        for section in sections:
-            section = section.strip()
-            if not section:
-                continue
-                
-            # Format headings
-            if section.startswith("#"):
-                # Ensure proper heading format with spacing
-                if not section.startswith("# ") and not section.startswith("## "):
-                    section = f"## {section.lstrip('#').strip()}"
-                formatted_sections.append(f"\n{section}\n")
-            else:
-                # Regular paragraph
-                formatted_sections.append(section)
-        
-        # Join sections with proper spacing
-        formatted_content = "\n\n".join(formatted_sections)
-        
-        # Ensure proper spacing around headings
-        formatted_content = formatted_content.replace("\n###", "\n\n###")
-        formatted_content = formatted_content.replace("\n##", "\n\n##")
-        formatted_content = formatted_content.replace("\n#", "\n\n#")
-        
-        return formatted_content
+    def _format_blog_content(self, content):
+        sections = content.strip().split("\n\n")
+        formatted = "\n\n".join(
+            f"\n\n{s.strip()}" if s.startswith("#") else s.strip()
+            for s in sections if s.strip()
+        )
+        return formatted.replace("\n###", "\n\n###").replace("\n##", "\n\n##").replace("\n#", "\n\n#")