blog generator implemented

app.py

@@ -0,0 +1,4 @@
+from blogGenerator.main import load_blog_generator_agentic_ai_app
+
+if __name__ == "__main__":
+    load_blog_generator_agentic_ai_app()

requirements.txt

@@ -0,0 +1,9 @@
+-e.
+python-dotenv
+streamlit
+langchain
+langgraph
+langchain-core
+langchain-groq
+langchain-community
+youtube_transcript_api

research/blog_generator.ipynb

@@ -0,0 +1,331 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "load_dotenv()\n",
+    "\n",
+    "os.environ[\"GROQ_API_KEY\"]=os.getenv(\"GROQ_API_KEY\")\n",
+    "os.environ[\"OPENAI_API_KEY\"]=os.getenv(\"OPENAI_API_KEY\")\n",
+    "os.environ[\"GOOGLE_API_KEY\"] = os.getenv(\"GOOGLE_API_KEY\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# from langchain_openai import ChatOpenAI\n",
+    "# llm = ChatOpenAI(model=\"gpt-4o\")\n",
+    "\n",
+    "\n",
+    "# from langchain_google_genai import ChatGoogleGenerativeAI\n",
+    "# llm = ChatGoogleGenerativeAI(model=\"gemini-1.5-flash\")\n",
+    "# llm = ChatGoogleGenerativeAI(model=\"gemini-2.0-flash\")\n",
+    "\n",
+    "from langchain_groq import ChatGroq\n",
+    "llm = ChatGroq(model=\"qwen-2.5-32b\")\n",
+    "# llm = ChatGroq(model=\"deepseek-r1-distill-qwen-32b\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='Hello! How can I assist you today?', additional_kwargs={}, response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 30, 'total_tokens': 40, 'completion_time': 0.05, 'prompt_time': 0.004556183, 'queue_time': 0.07078565599999999, 'total_time': 0.054556183}, 'model_name': 'qwen-2.5-32b', 'system_fingerprint': 'fp_c527211fd1', 'finish_reason': 'stop', 'logprobs': None}, id='run-529411a7-693a-4255-ad06-4e5ca0f33fe1-0', usage_metadata={'input_tokens': 30, 'output_tokens': 10, 'total_tokens': 40})"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm.invoke(\"Hi\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### State"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing_extensions import TypedDict\n",
+    "\n",
+    "\n",
+    "class State(TypedDict):\n",
+    "    \"\"\"\n",
+    "    Represents the structure of the state used in the graph.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    user_message: str\n",
+    "    decision: str\n",
+    "    yt_url: str\n",
+    "    blog_title: str\n",
+    "    blog_content: str"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Router"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import BaseModel, Field\n",
+    "from typing_extensions import Literal\n",
+    "from langchain_core.messages import SystemMessage, HumanMessage\n",
+    "\n",
+    "\n",
+    "class Route(BaseModel):\n",
+    "    step: Literal[\"youtube\", \"topic\"] = Field(\n",
+    "        None, description=\"The next step in the routing process\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def router(state: State):\n",
+    "\n",
+    "    print(f\"Node Called : router \\n {state}\")\n",
+    "\n",
+    "    route = llm.with_structured_output(Route)\n",
+    "\n",
+    "    decision = route.invoke(\n",
+    "        [\n",
+    "            SystemMessage(content=\"Route the user message to youtube or topic.\"),\n",
+    "            HumanMessage(content=state[\"user_message\"]),\n",
+    "        ]\n",
+    "    )\n",
+    "\n",
+    "    print(f\"Decision : {decision}\")\n",
+    "    if decision.step == \"youtube\":\n",
+    "        extract_url = llm.invoke(\n",
+    "            [\n",
+    "                SystemMessage(\n",
+    "                    content=\"Extract youtube url from user message. Only extract youtube link. Don't add any message.\"\n",
+    "                ),\n",
+    "                HumanMessage(content=state[\"user_message\"]),\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "        return {\"yt_url\": extract_url.content, \"decision\": \"yt\"}\n",
+    "\n",
+    "    return {\"decision\": decision.step}\n",
+    "\n",
+    "\n",
+    "def route_decision(state: State):\n",
+    "\n",
+    "    print(f\"state : {state}\")\n",
+    "    # Return the node name you want to visit next\n",
+    "    if state[\"decision\"] == \"youtube\":\n",
+    "        return \"youtube\"\n",
+    "    elif state[\"decision\"] == \"topic\":\n",
+    "        return \"topic\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Youtube Transcript"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from youtube_transcript_api import YouTubeTranscriptApi\n",
+    "\n",
+    "\n",
+    "def yt_transcipt(self, state: State) -> dict:\n",
+    "    \"\"\"Fetches transcript from a given YouTube URL\"\"\"\n",
+    "\n",
+    "    print(f\"Node Called : yt_transcipt\")\n",
+    "\n",
+    "    video_id = state[\"yt_url\"].replace(\"https://www.youtube.com/watch?v=\", \"\")\n",
+    "\n",
+    "    try:\n",
+    "        transcript = YouTubeTranscriptApi.get_transcript(video_id)\n",
+    "        output = \"\\n\".join([x[\"text\"] for x in transcript])\n",
+    "        print(\"✅ Transcription fetched successfully.\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"❌ Error fetching transcript: {e}\")\n",
+    "        output = \"\"\n",
+    "\n",
+    "    return {\"yt_transcription\": output}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Content Generator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class BlogContent(BaseModel):\n",
+    "    title: str = Field(description=\"Title of Blog\")\n",
+    "    content: str = Field(description=\"\")\n",
+    "\n",
+    "\n",
+    "def generate_blog_content(state: State):\n",
+    "\n",
+    "    blog_llm = llm.with_structured_output(BlogContent)\n",
+    "\n",
+    "    blog_content = blog_llm.invoke(\n",
+    "        [\n",
+    "            SystemMessage(content=\"Generate SEO Friendly Blog of User Topic\"),\n",
+    "            HumanMessage(content=f\"User Topic : {state['user_message']}\"),\n",
+    "        ]\n",
+    "    )\n",
+    "\n",
+    "    print(f\"### blog_content : {blog_content}\")\n",
+    "\n",
+    "    return blog_content"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Build Graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from langgraph.graph import START, END, StateGraph\n",
+    "\n",
+    "from IPython.display import Image, display\n",
+    "\n",
+    "\n",
+    "graph_builder = StateGraph(State)\n",
+    "\n",
+    "graph_builder.add_node(\"Router\", router)\n",
+    "graph_builder.add_node(\"yt_transcipt\", yt_transcipt)\n",
+    "graph_builder.add_node(\"generate_blog_content\", generate_blog_content)\n",
+    "\n",
+    "graph_builder.add_edge(START, \"Router\")\n",
+    "graph_builder.add_conditional_edges(\n",
+    "    \"Router\",\n",
+    "    route_decision,\n",
+    "    {\"youtube\": \"yt_transcipt\", \"topic\": \"generate_blog_content\"},\n",
+    ")\n",
+    "\n",
+    "graph_builder.add_edge(\"yt_transcipt\", \"generate_blog_content\")\n",
+    "\n",
+    "graph_builder.add_edge(\"generate_blog_content\", END)\n",
+    "\n",
+    "graph = graph_builder.compile()\n",
+    "\n",
+    "display(Image(graph.get_graph().draw_mermaid_png()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Invoke Graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Node Called : router \n",
+      " {'user_message': 'Langgraph'}\n",
+      "Decision : step='topic'\n",
+      "state : {'user_message': 'Langgraph', 'decision': 'topic'}\n",
+      "### blog_content : title='Mastering Langgraph: A Comprehensive Guide' content=\"Langgraph, a lesser-known but powerful tool in the world of language processing and graph theory, is making waves by offering innovative solutions to complex data analysis problems. In this blog post, we will explore what Langgraph is, how it works, its key features, and how it can be applied in real-world scenarios. \\n\\n### What is Langgraph?\\n\\nLanggraph is an advanced software designed to analyze the structure and relationships within language data, using graph theory principles. By representing language data as a network of nodes and edges, Langgraph helps researchers, data scientists, and developers visualize, analyze, and manipulate linguistic information. This makes it an invaluable tool for understanding the complex patterns and connections inherent in human language.\\n\\n### How Does Langgraph Work?\\n\\nAt its core, Langgraph converts textual data into a graph format, where each node represents a word or phrase, and edges represent relationships or connections between these nodes. These relationships can be based on syntactic, semantic, or even phonetic similarities. Once the data is transformed into a graph, users can apply various graph algorithms and analysis techniques to extract insights and patterns.\\n\\n### Key Features of Langgraph\\n\\n1. **Scalability**: Langgraph is designed to handle large datasets, making it suitable for big data applications.\\n2. **Interactivity**: It offers a user-friendly interface that allows users to interact with the graph data and explore relationships in real-time.\\n3. **Customizability**: Users can define their own graph structures and algorithms, catering to specific research or business needs.\\n4. **Integration**: Langgraph can be easily integrated into existing data processing pipelines and can work with various data formats, including text, audio, and even video.\\n5. **Visualization**: With advanced visualization tools, users can create detailed and interactive visual representations of their data, making it easier to understand complex relationships.\\n\\n### Real-World Applications of Langgraph\\n\\nLanggraph's capabilities make it suitable for a wide range of applications, from academic research to business intelligence. Here are a few examples:\\n\\n- **Academic Research**: Researchers can use Langgraph to uncover patterns in language evolution, comparative linguistics, and more.\\n- **Business Intelligence**: Companies can leverage Langgraph to analyze customer feedback, social media trends, and more to gain insights into consumer behavior.\\n- **Social Media Analysis**: Langgraph can help in understanding the spread of information and the influence of different entities in social media networks.\\n- **Natural Language Processing (NLP)**: Langgraph can play a significant role in NLP tasks such as sentiment analysis, topic modeling, and machine translation.\\n\\n### Conclusion\\n\\nLanggraph stands out as a cutting-edge tool for anyone interested in language data analysis and graph theory. Its unique approach to analyzing language through the lens of graph theory opens up new possibilities for understanding and utilizing linguistic data. Whether you are a researcher, a data scientist, or a business analyst, learning to harness the power of Langgraph can provide you with valuable insights and a competitive edge in your field.\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "messages = graph.invoke({\"user_message\": \"Langgraph\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

setup.py

@@ -0,0 +1,29 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+
+__version__ = "0.0.0"
+
+REPO_NAME = "Blog-Generator"
+AUTHOR_USER_NAME = "vrajpatel04"
+SRC_REPO = "blogGenerator"
+AUTHOR_EMAIL = "vraj04.patel@gmail.com"
+
+
+setuptools.setup(
+    name=SRC_REPO,
+    version=__version__,
+    author=AUTHOR_USER_NAME,
+    author_email=AUTHOR_EMAIL,
+    description="Blog Generator Automation Application",
+    long_description=long_description,
+    long_description_content="text/markdown",
+    url=f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}",
+    project_urls={
+        "Bug Tracker": f"https://github.com/{AUTHOR_USER_NAME}/{REPO_NAME}/issues",
+    },
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src")
+)

src/blogGenerator/LLMs/groqllm.py

@@ -0,0 +1,25 @@
+import os
+import streamlit as st
+from langchain_groq import ChatGroq
+
+
+class GroqLLM:
+    def __init__(self, user_controls_input):
+        self.user_controls_input = user_controls_input
+        print(f"#### self.user_controls_input : {self.user_controls_input}")
+
+    def get_llm_model(self):
+        try:
+            groq_api_key = self.user_controls_input["GROQ_API_KEY"]
+            selected_groq_model = self.user_controls_input["selected_groq_model"]
+            # print(f"$$$$ {groq_api_key == ""} {os.environ["GROQ_API_KEY"] == ""}")
+
+            # if groq_api_key == "" and os.environ["GROQ_API_KEY"] == "":
+            if groq_api_key == "":
+                st.error("Please Enter the Groq API KEY")
+
+            llm = ChatGroq(api_key=groq_api_key, model=selected_groq_model)
+
+        except Exception as e:
+            raise ValueError(f"Error Occurred with Exception : {e}")
+        return llm

src/blogGenerator/graph/graph_builder.py

@@ -0,0 +1,49 @@
+from langgraph.graph import START, END, StateGraph
+
+from blogGenerator.state.state import State
+from blogGenerator.nodes.route_deciding_node import RouteDecidingNode
+from blogGenerator.nodes.yt_transcript_node import YTTranscriptNode
+from blogGenerator.nodes.content_generator_node import ContentGeneratorNode
+
+
+class GraphBuilder:
+    def __init__(self, model):
+        self.llm = model
+        self.graph_builder = StateGraph(State)
+
+    def blog_generator_build_graph(self):
+        """
+        Build a blog generation graph
+        """
+
+        print("Build a blog generation graph.......")
+        try:
+            self.route_deciding_node = RouteDecidingNode(self.llm)
+            self.yt_transcript_node = YTTranscriptNode()
+            self.content_generator_node = ContentGeneratorNode(self.llm)
+
+            self.graph_builder.add_node("Router", self.route_deciding_node.process)
+            self.graph_builder.add_node(
+                "YT Transcript", self.yt_transcript_node.process
+            )
+            self.graph_builder.add_node(
+                "Generate Blog", self.content_generator_node.process
+            )
+
+            self.graph_builder.add_edge(START, "Router")
+            self.graph_builder.add_conditional_edges(
+                "Router",
+                self.route_deciding_node.route_decision,
+                {"youtube": "YT Transcript", "topic": "Generate Blog"},
+            )
+            self.graph_builder.add_edge("YT Transcript", "Generate Blog")
+            self.graph_builder.add_edge("Generate Blog", END)
+
+        except Exception as e:
+            print(f"Error : {e}")
+
+    def setup_graph(self):
+        self.blog_generator_build_graph()
+        print("setup_graph.......")
+
+        return self.graph_builder.compile()

src/blogGenerator/main.py

@@ -0,0 +1,42 @@
+import streamlit as st
+from blogGenerator.ui.streamlit.loadui import LoadStreamlitUI
+from blogGenerator.LLMs.groqllm import GroqLLM
+from blogGenerator.graph.graph_builder import GraphBuilder
+
+from blogGenerator.ui.streamlit.display_result import DisplayResultStreamlit
+
+
+def load_blog_generator_agentic_ai_app():
+
+    # Load UI
+    ui = LoadStreamlitUI()
+    user_config = ui.load_streamlit_ui()
+
+    if not user_config:
+        st.error("Error: Failed to load user input from the UI.")
+        return
+
+    user_message = st.chat_input("Enter your message:")
+
+    if user_message:
+        try:
+            st.write("Initialize Blog Generation....")
+
+            # Configure LLM
+            obj_llm_config = GroqLLM(user_controls_input=user_config)
+            model = obj_llm_config.get_llm_model()
+            if not model:
+                st.error("Error: LLM model could not be initialized.")
+                return
+
+            ### Graph Builder
+            graph_builder = GraphBuilder(model)
+            try:
+                graph = graph_builder.setup_graph()
+                DisplayResultStreamlit(graph, user_message).display_result_on_ui()
+
+            except Exception as e:
+                st.error(f"Error: Graph setup failed - {e}")
+                return
+        except Exception as e:
+            raise ValueError(f"Error Occurred with Exception : {e}")

src/blogGenerator/nodes/content_generator_node.py

@@ -0,0 +1,57 @@
+from blogGenerator.state.state import State
+from pydantic import BaseModel, Field
+
+from langchain_core.messages import SystemMessage, HumanMessage
+
+
+class BlogContent(BaseModel):
+    title: str = Field(description="Title of the Blog")
+    content: str = Field(description="Content of the Blog")
+
+
+class ContentGeneratorNode:
+    def __init__(self, model):
+        self.llm = model
+
+    def process(self, state: State):
+
+        print(f"Node Called : ContentGeneratorNode ---> {state["decision"]}")
+
+        blog_llm = self.llm.with_structured_output(BlogContent)
+
+        system_prompt = f"""
+                You are an expert SEO content writer specializing in generating high-quality, search-engine-optimized blog posts. Your goal is to create engaging, well-structured, and informative content that ranks well on search engines. Ensure the following best practices:
+
+                <Instruction>
+                    - Structure the blog into well-defined paragraphs.
+                    - Use bullet points where appropriate for clarity.
+                    - Keep sentences concise and easy to read.
+                    - Maintain a professional yet engaging tone.
+                    - Ensure natural integration of relevant keywords for SEO optimization.
+                    - Address common user queries to match search intent.
+                    - Include a strong conclusion with a clear call to action.
+                    - Ensure the blog is original, well-researched, and free from AI-detectable patterns. The word count should typically be between 800-1500 words, depending on the topic.
+                </Instruction>
+            """
+
+        if state["decision"] == "topic":
+            human_prompt = (
+                f"Generate an SEO-optimized blog post on {state['user_message']}"
+            )
+
+        elif state["decision"] == "youtube":
+            human_prompt = f"Generate an SEO-optimized blog post from this YouTube transcript: {state['yt_transcript']}."
+
+        blog = blog_llm.invoke(
+            [SystemMessage(content=system_prompt), HumanMessage(content=human_prompt)]
+        )
+
+        # print(f"### blog : {blog}")
+        # print(f"### blog_title : {blog.title}")
+        # print(f"### blog_content : {blog.content}")
+
+        return {
+            "blog_title": blog.title,
+            "blog_content": blog.content,
+            "final_content": "\n\n---\n\n".join([blog.title, blog.content]),
+        }

src/blogGenerator/nodes/route_deciding_node.py

@@ -0,0 +1,58 @@
+from pydantic import BaseModel, Field
+from typing_extensions import Literal
+from blogGenerator.state.state import State
+from langchain_core.messages import SystemMessage, HumanMessage
+
+
+class Route(BaseModel):
+    step: Literal["youtube", "topic"] = Field(
+        None, description="The next step in the routing process"
+    )
+
+
+class RouteDecidingNode:
+    """
+    Decides where to route the query based on the user input.
+    """
+
+    def __init__(self, model):
+        self.llm = model
+
+    def process(self, state: State):
+
+        # print(f"state['user_message'] : {state['user_message']}")
+        print(f"Node Called : RouteDecidingNode")
+
+        route = self.llm.with_structured_output(Route)
+
+        decision = route.invoke(
+            [
+                SystemMessage(content="Route the user message to youtube or topic."),
+                HumanMessage(content=state["user_message"]),
+            ]
+        )
+
+        print(f"decision : {decision}")
+
+        if decision.step == "youtube":
+            extract_url = self.llm.invoke(
+                [
+                    SystemMessage(
+                        content="Extract youtube url from user message. Only extract youtube link. Don't add any message."
+                    ),
+                    HumanMessage(content=state["user_message"]),
+                ]
+            )
+
+            return {"yt_url": extract_url.content, "decision": "youtube"}
+
+        return {"decision": decision.step}
+
+    def route_decision(self, state: State):
+
+        print(f"state : {state}")
+        # Return the node name you want to visit next
+        if state["decision"] == "youtube":
+            return "youtube"
+        elif state["decision"] == "topic":
+            return "topic"

src/blogGenerator/nodes/yt_transcript_node.py

@@ -0,0 +1,26 @@
+from blogGenerator.state.state import State
+from youtube_transcript_api import YouTubeTranscriptApi
+
+
+class YTTranscriptNode:
+    """
+    Get Youtube transcription
+    """
+
+    def process(self, state: State) -> dict:
+        """Fetches transcript from a given YouTube URL"""
+
+        print(f"Node Called : yt_transcipt")
+
+        video_id = state["yt_url"].replace("https://www.youtube.com/watch?v=", "")
+
+        try:
+            transcript = YouTubeTranscriptApi.get_transcript(video_id)
+            output = "\n".join([x["text"] for x in transcript])
+            # print(f"Output : {output}")
+            print("✅ Transcription fetched successfully.")
+        except Exception as e:
+            print(f"❌ Error fetching transcript: {e}")
+            output = ""
+
+        return {"yt_transcript": output}

src/blogGenerator/state/state.py

@@ -0,0 +1,15 @@
+from typing_extensions import TypedDict
+
+
+class State(TypedDict):
+    """
+    Represents the structure of the state used in the graph.
+    """
+
+    user_message: str
+    decision: str
+    yt_url: str
+    yt_transcript: str = ""
+    blog_title: str = ""
+    blog_content: str = ""
+    final_content: str = ""

src/blogGenerator/ui/streamlit/display_result.py

@@ -0,0 +1,40 @@
+import streamlit as st
+
+
+class DisplayResultStreamlit:
+    def __init__(self, graph, user_message):
+        self.graph = graph
+        self.user_message = user_message
+
+    def display_result_on_ui(self):
+        graph = self.graph
+        user_message = self.user_message
+
+        print(f"### user_message : {user_message}")
+
+        with st.chat_message("user"):
+            st.write(user_message)
+
+        # messages = graph.invoke({"user_message": user_message})
+
+        # Stream through the graph and get the response events
+        for event in graph.stream({"user_message": user_message}):
+            # print(event.values())
+            for value in event.values():
+                # # Show user message
+                # if "yt_url" in value:
+                #     continue  # Skip redundant yt_url display
+
+                # if "blog_title" in value:
+                #     with st.chat_message("assistant"):
+                #         st.write(f"Assistant: {value['blog_title']}")
+
+                # if "blog_content" in value:
+                #     with st.chat_message("assistant"):
+                #         st.write(f"Assistant: {value['blog_content']}")
+                if "blog_title" in value or "blog_content" in value:
+                    with st.chat_message("assistant"):
+                        if "blog_title" in value:
+                            st.markdown(f"**{value['blog_title']}**")  # Bold title
+                        if "blog_content" in value:
+                            st.write(value["blog_content"])  # Display blog content

src/blogGenerator/ui/streamlit/loadui.py

@@ -0,0 +1,55 @@
+import streamlit as st
+
+from blogGenerator.ui.uiconfigfile import Config
+
+
+class LoadStreamlitUI:
+    def __init__(self):
+        self.config = Config()
+        self.user_controls = {}
+
+    def initialize_session(self):
+        return {
+            "current_step": "requirements",
+        }
+
+    def load_streamlit_ui(self):
+        st.set_page_config(
+            page_title="🤖 " + self.config.get_page_title(), layout="wide"
+        )
+        st.header("🤖 " + self.config.get_page_title())
+        # st.session_state.timeframe = ""
+        # st.session_state.IsFetchButtonClicked = False
+        # st.session_state.IsSDLC = False
+
+        with st.sidebar:
+            # Get options from config
+            llm_options = self.config.get_llm_options()
+
+            # LLM selection
+            self.user_controls["selected_llm"] = st.selectbox("Select LLM", llm_options)
+
+            if self.user_controls["selected_llm"] == "Groq":
+                # Model selection
+                model_options = self.config.get_groq_model_options()
+                self.user_controls["selected_groq_model"] = st.selectbox(
+                    "Select Model", model_options
+                )
+                # API key input
+                self.user_controls["GROQ_API_KEY"] = st.session_state[
+                    "GROQ_API_KEY"
+                ] = st.text_input(
+                    "API Key",
+                    type="password",
+                    value="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",
+                )
+                # Validate API key
+                if not self.user_controls["GROQ_API_KEY"]:
+                    st.warning(
+                        "⚠️ Please enter your GROQ API key to proceed. Don't have? refer : https://console.groq.com/keys "
+                    )
+
+            if "state" not in st.session_state:
+                st.session_state.state = self.initialize_session()
+
+        return self.user_controls

src/blogGenerator/ui/uiconfigfile.ini

@@ -0,0 +1,5 @@
+[DEFAULT]
+PAGE_TITLE = Agentic AI Powered Blog Generator 
+LLM_OPTIONS = Groq
+USECASE_OPTIONS = Blog generator AI Agent
+GROQ_MODEL_OPTIONS = qwen-2.5-32b, deepseek-r1-distill-llama-70b

src/blogGenerator/ui/uiconfigfile.py

@@ -0,0 +1,16 @@
+from configparser import ConfigParser
+
+
+class Config:
+    def __init__(self, config_file="./src/blogGenerator/ui/uiconfigfile.ini"):
+        self.config = ConfigParser()
+        self.config.read(config_file)
+
+    def get_llm_options(self):
+        return self.config["DEFAULT"].get("LLM_OPTIONS").split(", ")
+
+    def get_groq_model_options(self):
+        return self.config["DEFAULT"].get("GROQ_MODEL_OPTIONS").split(", ")
+
+    def get_page_title(self):
+        return self.config["DEFAULT"].get("PAGE_TITLE")

templates.py

@@ -0,0 +1,39 @@
+import os
+from pathlib import Path
+import logging
+
+# logging string
+logging.basicConfig(level=logging.INFO, format="[%(asctime)s]: %(message)s:")
+
+project_name = "blogGenerator"
+
+list_of_files = [
+    ".github/workflows/.gitkeep",
+    "app.py",
+    f"src/{project_name}/__init__.py",
+    f"src/{project_name}/main.py",
+    f"src/{project_name}/LLMs/__init__.py",
+    f"src/{project_name}/graph/__init__.py",
+    f"src/{project_name}/state/__init__.py",
+    f"src/{project_name}/state/state.py",
+    f"src/{project_name}/nodes/__init__.py",
+    "requirements.txt",
+    "research/trials.ipynb",
+]
+
+
+for filepath in list_of_files:
+    filepath = Path(filepath)
+    filedir, filename = os.path.split(filepath)
+
+    print("filedir", filedir, "----", filename)
+
+    if filedir != "":
+        os.makedirs(filedir, exist_ok=True)
+        logging.info(f"Creating directory; {filedir} for the file: {filename}")
+    if (not os.path.exists(filepath)) or (os.path.getsize(filepath) == 0):
+        with open(filepath, "w") as f:
+            pass
+            logging.info(f"Creating empty file: {filepath}")
+    else:
+        logging.info(f"{filename} is already exists")