basic blog generation & code review added

src/langgraphagenticai/graph/graph_builder.py

@@ -5,6 +5,8 @@ from src.langgraphagenticai.state.state import State
 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 src.langgraphagenticai.nodes.blog_generation_node import BlogGenerationNode
+from src.langgraphagenticai.nodes.code_peer_review_node import CodeReviewerNode
 
 class GraphBuilder:
 
@@ -52,6 +54,41 @@ class GraphBuilder:
             self.graph_builder.add_edge(START,"chatbot")
             self.graph_builder.add_conditional_edges("chatbot", tools_condition)
             self.graph_builder.add_edge("tools","chatbot")
+    def blog_generation_build_graph(self):
+        """
+        Builds a blog generation graph.
+        Includes orchestrator, worker (llm_call), and synthesizer nodes.
+        """
+        blog_node = BlogGenerationNode(self.llm)
+
+        # Add nodes
+        self.graph_builder.add_node("orchestrator", blog_node.orchestrator)
+        self.graph_builder.add_node("llm_call", blog_node.llm_call)
+        self.graph_builder.add_node("synthesizer", blog_node.synthesizer)
+
+        # Define edges
+        self.graph_builder.add_edge(START, "orchestrator")
+        self.graph_builder.add_conditional_edges(
+            "orchestrator",
+            blog_node.assign_workers,
+            {
+                "llm_call": "llm_call"  # Maps to the worker node
+            }
+        )
+        self.graph_builder.add_edge("llm_call", "synthesizer")
+        self.graph_builder.add_edge("synthesizer", END)
+
+    def code_reviewer_build_graph(self):
+        """
+        Builds a code reviewer graph.
+        Includes a single node to review code and output feedback.
+        """
+        code_reviewer_node = CodeReviewerNode(self.llm)
+        self.graph_builder.add_node("reviewer", code_reviewer_node.review_code)
+        self.graph_builder.add_edge(START, "reviewer")
+        self.graph_builder.add_edge("reviewer", END)
+
+   
 
     def setup_graph(self,usecase: str):
         """
@@ -61,4 +98,10 @@ class GraphBuilder:
             self.basic_chatbot_build_graph()
         elif usecase == "Chatbot with Tool":
             self.chatbot_with_tools_build_graph()
+        elif usecase == "Blog Generation":
+            self.blog_generation_build_graph()
+        elif usecase == "Coding Peer Review":
+            self.code_reviewer_build_graph()
+        else:
+            raise ValueError(f"Unknown use case: {usecase}")
         return self.graph_builder.compile()

src/langgraphagenticai/nodes/blog_generation_node.py

@@ -0,0 +1,53 @@
+# blog_generation_node.py
+from src.langgraphagenticai.state.state import State, WorkerState, Section
+from pydantic import BaseModel, Field
+from typing import List
+from langgraph.constants import Send
+from langchain_core.messages import HumanMessage, SystemMessage
+
+class Sections(BaseModel):
+    sections: List[Section] = Field(description="Sections of the report.")
+
+class BlogGenerationNode:
+    def __init__(self, model):
+        # Planner uses structured output for sections
+        self.planner = model.with_structured_output(Sections)
+        # LLM for content generation does not use structured output
+        self.llm = model  # Raw LLM for generating text
+
+    def orchestrator(self, state: State) -> dict:
+        """Orchestrator that generates a plan for the report"""
+        report_sections = self.planner.invoke(
+            [
+                SystemMessage(content="Generate a plan for the report."),
+                HumanMessage(content=f"Here is the report topic: {state['topic']}"),
+            ]
+        )
+        print("Report Sections:", report_sections)
+        return {"sections": report_sections.sections}
+
+    def llm_call(self, state: WorkerState) -> dict:
+        """Worker writes a section of the report"""
+        section_content = 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}"
+                ),
+            ]
+        )
+        # Ensure we get the content as a string
+        content = section_content.content if hasattr(section_content, "content") else str(section_content)
+        return {"completed_sections": [content]}
+
+    def synthesizer(self, state: State) -> dict:
+        """Synthesize full report from sections"""
+        completed_sections = state["completed_sections"]
+        completed_report_sections = "\n\n---\n\n".join(completed_sections)
+        return {"final_report": completed_report_sections}
+
+    def assign_workers(self, state: State) -> List[Send]:
+        """Assign a worker to each section in the plan"""
+        return [Send("llm_call", {"section": s}) for s in state["sections"]]

src/langgraphagenticai/nodes/code_peer_review_node.py

@@ -0,0 +1,21 @@
+# code_reviewer_node.py
+from src.langgraphagenticai.state.state import State
+from langchain_core.messages import HumanMessage, SystemMessage
+
+class CodeReviewerNode:
+    def __init__(self, model):
+        self.llm = model
+
+    def review_code(self, state: State) -> dict:
+        """Review the provided code and return feedback"""
+        code = state["code_input"]
+        review = self.llm.invoke(
+            [
+                SystemMessage(content="Review the following code and provide feedback in markdown format."),
+                HumanMessage(content=code),
+            ]
+        )
+        return {
+            "messages": [SystemMessage(content="Code review completed")],
+            "review_output": review.content
+        }

src/langgraphagenticai/state/state.py

@@ -1,10 +1,45 @@
-from typing import Annotated, Literal, Optional, List
+# from typing import Annotated, Literal, Optional, List
+# from typing_extensions import TypedDict
+# from langgraph.graph.message import add_messages
+# from langchain_core.messages import HumanMessage, AIMessage
+
+# class State(TypedDict):
+#     """
+#     Represents the structure of the state used in the graph.
+#     """
+#     messages: Annotated[list,add_messages]
+
+# state.py
+from typing import Annotated, List, Optional
 from typing_extensions import TypedDict
 from langgraph.graph.message import add_messages
-from langchain_core.messages import HumanMessage, AIMessage
+import operator
+from pydantic import BaseModel, Field
 
-class State(TypedDict):
+# Schema for Blog Generation sections
+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.")
+
+# Unified State for all use cases
+class State(TypedDict, total=False):  # total=False makes all fields optional
     """
-    Represents the structure of the state used in the graph.
+    Represents the structure of the state used in the graph for multiple use cases:
+    - Chat Bot: messages
+    - Bot with Tool: messages, tool_output
+    - Blog Generation: messages, topic, sections, completed_sections, final_report
+    - Code Reviewer: messages, code_input, review_output
     """
-    messages: Annotated[list,add_messages]
+    messages: Annotated[List, add_messages]  # Common to all: Chat history
+    topic: str  # Blog Generation: Report topic
+    sections: List[Section]  # Blog Generation: List of report sections
+    completed_sections: Annotated[List[str], operator.add]  # Blog Generation: Completed sections
+    final_report: str  # Blog Generation: Final report
+    tool_output: str  # Bot with Tool: Output from tool execution
+    code_input: str  # Code Reviewer: Input code to review
+    review_output: str  # Code Reviewer: Review results
+
+# Worker State for Blog Generation
+class WorkerState(TypedDict):
+    section: Section
+    completed_sections: Annotated[List[str], operator.add]

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -37,4 +37,36 @@ class DisplayResultStreamlit:
                         st.write("Tool Call End")
                 elif type(message)==AIMessage and message.content:
                     with st.chat_message("assistant"):
-                        st.write(message.content)
+                        st.write(message.content)
+        elif usecase == "Blog Generation":
+            # Prepare state and invoke the graph for blog generation
+            initial_state = {
+                "messages": [HumanMessage(content=user_message)],
+                "topic": user_message,  # Assume user_message is the topic
+                "sections": [],
+                "completed_sections": [],
+                "final_report": ""
+            }
+            res = graph.invoke(initial_state)
+            with st.chat_message("user"):
+                st.write(f"Blog topic: {user_message}")
+            with st.chat_message("assistant"):
+                st.markdown("### Generated Blog")
+                st.markdown(res["final_report"])  # Display the final report in markdown
+
+        elif usecase == "Coding Peer Review":
+            # Prepare state and invoke the graph for code review
+            initial_state = {
+                "messages": [HumanMessage(content="Review this code")],
+                "code_input": user_message,  # Assume user_message is the code
+                "review_output": ""
+            }
+            res = graph.invoke(initial_state)
+            with st.chat_message("user"):
+                st.code(user_message, language="python")  # Display code in a code block
+            with st.chat_message("assistant"):
+                st.markdown("### Code Review Feedback")
+                st.markdown(res["review_output"])  # Display review in markdown
+
+        else:
+            st.error(f"Unknown use case: {usecase}")

src/langgraphagenticai/ui/uiconfigfile.ini

@@ -1,5 +1,5 @@
 [DEFAULT]
-PAGE_TITLE = LangGraph: Build Stateful Agentic AI graph
+PAGE_TITLE = Dynamic Multi-Agent Workflows with LangGraph: Scalable, Modular, and Intelligent
 LLM_OPTIONS = Groq
-USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool
+USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool, Blog Generation, Coding Peer Review
 GROQ_MODEL_OPTIONS = mixtral-8x7b-32768, llama3-8b-8192, llama3-70b-8192, gemma-7b-i, gemma2-9b-it, qwen2.5-32b, qwen-2.5-coder-32b