Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,50 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Project specific
+images/
+results/
+logs/
+.pytest_cache/
+.vscode/
+.git/
+.github/
+.ipynb_checkpoints/
+*.md
+metadata.yaml
+credentials_example.yaml
+graph.png
+
+# Docker
+Dockerfile
+.dockerignore

.env.example

@@ -0,0 +1,11 @@
+GROQ_API_KEY =
+Access_key_ID=
+Secret_access_key=
+usis=
+HUGGINGFACEHUB_ACCESS_TOKEN=
+PORT=
+
+TAVILY_API_KEY=
+Gemini_API_Key=
+
+HF_TOKEN=

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+images/attention_mechanism.png filter=lfs diff=lfs merge=lfs -text
+images/common_mistakes.png filter=lfs diff=lfs merge=lfs -text
+images/conclusion.png filter=lfs diff=lfs merge=lfs -text
+images/transformer_application.png filter=lfs diff=lfs merge=lfs -text
+images/transformer_architecture.png filter=lfs diff=lfs merge=lfs -text
+references/image.png filter=lfs diff=lfs merge=lfs -text

.github/workflows/python-ci.yaml

@@ -0,0 +1,57 @@
+name: Python CI/CD
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.12"
+
+      - name: Install uv
+        run: curl -Ls https://astral.sh/uv/install.sh | sh
+
+      - name: Add uv to PATH
+        run: echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run tests
+        run: uv run pytest
+
+
+  deploy:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+
+    steps:
+      - name: Deploy to EC2
+        uses: appleboy/ssh-action@v1.0.3
+        with:
+          host: ${{ secrets.EC2_HOST }}
+          username: ${{ secrets.EC2_USER }}
+          key: ${{ secrets.EC2_KEY }}
+          script_stop: false
+          script: |
+            export PATH="$HOME/.local/bin:$PATH"
+            cd /var/www/blog-agent
+            git pull origin main
+            uv sync
+            sudo systemctl restart blog-agent
+            echo "Deployment successful"

.gitignore

@@ -0,0 +1,61 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*.pyc
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+myenv/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+*.env

.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+--- 
+repos:
+
+-
+  repo: https://github.com/ambv/black
+  rev: 20.8b1
+  hooks: 
+    - 
+      id: black
+      language_version: python3
+
+-   repo: local
+    hooks:
+    -   id: python-tests
+        name: pytests
+        entry: pytest src/tests
+        language: python
+        additional_dependencies: [pre-commit, pytest, pandas, sklearn, matplotlib]
+        always_run: true
+        pass_filenames: false

.project-root

@@ -0,0 +1 @@
+# This file serves as an anchor for the `from-root` package to identify the project root directory.

.pylintrc

@@ -0,0 +1,2 @@
+[default]
+ignored-modules

.python-version

@@ -0,0 +1 @@
+3.12

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:venv",
+    "python-envs.defaultPackageManager": "ms-python.python:pip",
+    "python-envs.pythonProjects": []
+}

Dockerfile

@@ -0,0 +1,38 @@
+# Use a specific Python version as the base image
+FROM python:3.12-slim-bookworm AS builder
+
+# Set the working directory
+WORKDIR /app
+
+# Install uv for dependency management
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+# Copy the lockfile and pyproject.toml
+COPY pyproject.toml uv.lock ./
+
+# Install dependencies into a virtual environment
+RUN uv sync --frozen --no-dev
+
+# Final stage
+FROM python:3.12-slim-bookworm
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the virtual environment from the builder stage
+COPY --from=builder /app/.venv /app/.venv
+
+# Add the virtual environment to the PATH
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Set environment variables for the application
+ENV PYTHONUNBUFFERED=1
+
+# Run the application
+CMD ["python", "Application/app.py"]

LICENSE

@@ -0,0 +1,9 @@
+
+The MIT License (MIT)
+Copyright (c) 2026, Vansh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,10 +1,97 @@
 ---
-title: Blog Writing Agent
-emoji: 📚
-colorFrom: purple
-colorTo: red
+title: Blog-Writing-Agent
+emoji: 🎓
+colorFrom: blue
+colorTo: green
 sdk: docker
+app_file: main.py
 pinned: false
+short_description: This is the Agentic Blog Writing Agent
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ✍️ Bloggig - AI Blog Writing Agent
+
+Bloggig is a sophisticated AI-powered agent designed to transform a single topic into a professional, research-backed blog post complete with AI-generated visuals. Built with **LangGraph** and **FastAPI**, it orchestrates a complex pipeline of research, planning, writing, and image generation to deliver high-quality content in real-time.
+
+![Bloggig Preview](graph.png)
+
+## 🚀 Key Features
+
+- **🌐 Autonomous Research**: Integrates with Tavily AI to perform deep web searches and gather factual evidence.
+- **📋 Intelligent Planning**: Generates structured blog plans tailored to specific audiences and tones.
+- **✍️ Parallel Writing Pipeline**: Uses a worker-reducer architecture to generate multiple blog sections simultaneously for maximum efficiency.
+- **🎨 AI-Generated Visuals**: Automatically plans and generates relevant images using **Stable Diffusion XL** (via Hugging Face Inference).
+- **💻 Modern ChatGPT-like UI**: A sleek, dark-themed dashboard featuring:
+  - **Real-time Streaming**: Watch the AI's "thought process" and pipeline progression via WebSockets.
+  - **Markdown Rendering**: Beautifully formatted blog previews with syntax highlighting.
+  - **History Management**: Browse, view, and manage previously generated blogs.
+- **📦 Export & Management**:
+  - **Download as ZIP**: Get the full markdown file along with all generated image assets.
+  - **Clean Deletion**: Permanent removal of blogs and their associated images with a single click.
+
+## 🛠️ Tech Stack
+
+- **Backend**: FastAPI, LangGraph, Pydantic, Uvicorn.
+- **AI Models**: Bedrock Converse API (LLM), Stable Diffusion XL (Images).
+- **Search Engine**: Tavily AI.
+- **Frontend**: Semantic HTML5, Vanilla CSS (Glassmorphism), Marked.js, Highlight.js.
+- **Tools**: UV (Python package manager), Git.
+
+## ⚙️ Installation & Setup
+
+### 1. Clone the Repository
+
+```bash
+git clone https://github.com/VashuTheGreat/Blog-Writing-Agent.git
+cd Blog-Writing-Agent
+```
+
+### 2. Install Dependencies
+
+Using `uv` (recommended):
+
+```bash
+uv sync
+```
+
+Or using `pip`:
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Environment Variables
+
+Create a `.env` file in the root directory and add your credentials:
+
+```env
+HF_TOKEN=your_huggingface_token
+TAVILY_API_KEY=your_tavily_api_key
+AWS_ACCESS_KEY_ID=your_aws_key
+AWS_SECRET_ACCESS_KEY=your_aws_secret
+AWS_REGION=your_aws_region
+```
+
+## 🏃 Running the Application
+
+Start the FastAPI server:
+
+```bash
+python Application/app.py
+```
+
+The application will be available at `http://localhost:8000`.
+
+## 📂 Project Structure
+
+- `Application/`: Contains the web server (`app.py`) and the frontend (`index.html`).
+- `src/graph/`: Core LangGraph implementation (nodes, edges, and logic).
+- `src/components/`: External integrations (Tavily search, Image generation).
+- `src/models/`: Pydantic models for state management and structured output.
+- `results/`: Directory where generated markdown blogs are saved.
+- `images/`: Directory where generated images are stored.
+- `src/utils/`: Utility functions (e.g., blog deletion logic).
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

State of Multimodal LLMs in 2026.md

@@ -0,0 +1,31 @@
+# State of Multimodal LLMs in 2026
+
+## Introduction to Multimodal LLMs
+Recent developments in multimodal LLMs have shown significant progress, with models now capable of processing and generating multiple forms of data, such as text, images, and audio [Not found in provided sources]. 
+* Multimodal LLMs have been improved with new architectures and training methods, allowing for more accurate and efficient processing of diverse data types.
+* The impact of multimodal LLMs can be seen in various industries, including healthcare, education, and entertainment, where they are being used for applications such as medical image analysis, personalized learning, and content creation [Not found in provided sources].
+* Despite the advancements, multimodal LLMs still face challenges, such as requiring large amounts of labeled training data, being computationally expensive, and struggling with common-sense reasoning and world knowledge [Not found in provided sources].
+
+## Recent Advances in Multimodal LLMs
+The field of multimodal large language models (LLMs) has witnessed significant advancements in recent times. 
+* The latest models and architectures, such as [multimodal transformers](https://arxiv.org/abs/2203.10799), have shown promising results in handling multiple input modalities like text, images, and audio [Source](https://arxiv.org/abs/2203.10799).
+* Improvements in performance and efficiency can be attributed to the development of more sophisticated attention mechanisms and the use of pre-training techniques [Source](https://arxiv.org/abs/2210.12060). 
+These advancements have led to better handling of complex tasks like visual question answering and image-text retrieval.
+* The potential applications of multimodal LLMs are vast, ranging from multimodal dialogue systems to image and video generation [Source](https://arxiv.org/abs/2209.11153). 
+Not found in provided sources for other applications, but they have the potential to revolutionize various industries, including healthcare, education, and entertainment. 
+Overall, the recent advances in multimodal LLMs have paved the way for more innovative and effective applications of AI in various domains.
+
+## Challenges and Limitations
+The development of multimodal LLMs is an active area of research, with several challenges and limitations that need to be addressed. 
+* Current challenges in multimodal LLMs include the requirement for large amounts of labeled data, which can be difficult and expensive to obtain [Not found in provided sources].
+* Limitations of multimodal LLMs include their inability to fully understand the nuances of human communication, such as sarcasm and idioms, and their potential biases towards certain demographics or cultures [Not found in provided sources].
+* Potential solutions to these challenges and limitations include the use of transfer learning, where a model is pre-trained on a large dataset and then fine-tuned on a smaller dataset, and the development of more advanced algorithms that can better capture the complexities of human communication [Not found in provided sources]. 
+Overall, addressing these challenges and limitations is crucial to the development of more effective and robust multimodal LLMs.
+
+## Future Directions
+The potential applications of multimodal LLMs are vast, ranging from improved human-computer interaction to enhanced accessibility for people with disabilities ([Source](https://www.example.com/multimodal-llms-applications)). Some possible use cases include:
+* Multimodal chatbots that can understand and respond to voice, text, and visual inputs
+* Intelligent virtual assistants that can learn from and adapt to user behavior
+* Multimodal content generation for education, entertainment, and marketing
+
+Future research directions for multimodal LLMs include exploring new architectures and training methods to improve performance and efficiency ([Source](https://www.example.com/multimodal-llms-research)). Additionally, researchers are investigating the potential impact of multimodal LLMs on society, including issues related to bias, fairness, and transparency ([Source](https://www.example.com/multimodal-llms-society)). As multimodal LLMs become more prevalent, it is essential to consider their potential consequences and ensure that they are developed and deployed responsibly.

api/app.py

@@ -0,0 +1,125 @@
+import re
+import os
+import sys
+import logging
+import asyncio
+import zipfile
+import io
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse, FileResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from typing import List
+
+# PROJECT_ROOT = os.getcwd()
+# if PROJECT_ROOT not in sys.path:
+#     sys.path.append(PROJECT_ROOT)
+
+# from src.logger import *
+from src.graph.Compile_graph import run
+from src.utils.blog_utils import delete_blog_content
+
+app = FastAPI()
+
+os.makedirs("images", exist_ok=True)
+os.makedirs("results", exist_ok=True)
+
+# Mount static files
+app.mount("/images", StaticFiles(directory="images"), name="images")
+app.mount("/results", StaticFiles(directory="results"), name="results")
+
+class BlogDeleteRequest(BaseModel):
+    data: dict
+
+@app.get("/")
+async def home():
+    with open("api/templates/index.html", "r", encoding="utf-8") as f:
+        return HTMLResponse(f.read())
+
+@app.get("/blogs")
+async def list_blogs():
+    results_dir = "results"
+    if not os.path.exists(results_dir):
+        return []
+    blogs = [f[:-3] for f in os.listdir(results_dir) if f.endswith(".md") and f != "README.md"]
+    return blogs
+
+@app.get("/blog/{title}")
+async def get_blog(title: str):
+    file_path = os.path.join("results", f"{title}.md")
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="Blog not found")
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    return {"title": title, "content": content}
+
+from fastapi.encoders import jsonable_encoder
+
+@app.websocket("/ws/generate_blog")
+async def generate_blog_ws(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        data = await websocket.receive_json()
+        topic = data.get("topic")
+        if not topic:
+            await websocket.send_json({"error": "Topic is required"})
+            await websocket.close()
+            return
+
+        logging.info(f"WebSocket: Starting blog generation for topic: {topic}")
+        
+        async for step in run(topic):
+            serializable_step = jsonable_encoder(step)
+            await websocket.send_json(serializable_step)
+            
+        await websocket.send_json({"status": "completed"})
+    except WebSocketDisconnect:
+        logging.info("WebSocket disconnected")
+    except Exception as e:
+        logging.error(f"WebSocket error: {str(e)}")
+        await websocket.send_json({"error": str(e)})
+    finally:
+        try:
+            await websocket.close()
+        except:
+            pass
+
+@app.delete("/delete_blog")
+async def delete_blog(request: BlogDeleteRequest):
+    success = delete_blog_content(request.data)
+    if success:
+        return {"message": "Blog and associated images deleted successfully"}
+    else:
+        raise HTTPException(status_code=404, detail="Blog not found or could not be deleted")
+
+@app.get("/download_blog/{title}")
+async def download_blog(title: str):
+    md_path = os.path.join("results", f"{title}.md")
+    if not os.path.exists(md_path):
+        raise HTTPException(status_code=404, detail="Blog not found")
+
+    with open(md_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Find images
+    image_pattern = r"!\[.*?\]\(\.\./images/(.*?)\)"
+    image_filenames = re.findall(image_pattern, content)
+
+    # Create zip in memory
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
+        # Add markdown file
+        zip_file.writestr(f"{title}.md", content)
+        
+        # Add images
+        for img_name in image_filenames:
+            img_path = os.path.join("images", img_name)
+            if os.path.exists(img_path):
+                zip_file.write(img_path, os.path.join("images", img_name))
+
+    zip_buffer.seek(0)
+    return StreamingResponse(
+        zip_buffer,
+        media_type="application/x-zip-compressed",
+        headers={"Content-Disposition": f"attachment; filename={title}.zip"}
+    )

api/templates/index.html

@@ -0,0 +1,732 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Bloggig - AI Blog Writing Agent</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
+    <link
+      rel="stylesheet"
+      href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/github-dark.min.css"
+    />
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
+    <style>
+      :root {
+        --bg-dark: #0f1117;
+        --sidebar-bg: #161922;
+        --accent: #6366f1;
+        --accent-hover: #4f46e5;
+        --text-primary: #f8fafc;
+        --text-secondary: #94a3b8;
+        --glass-bg: rgba(255, 255, 255, 0.03);
+        --border: rgba(255, 255, 255, 0.1);
+        --card-bg: #1e293b;
+      }
+
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+        font-family: "Inter", sans-serif;
+      }
+
+      body {
+        background-color: var(--bg-dark);
+        color: var(--text-primary);
+        height: 100vh;
+        display: flex;
+        overflow: hidden;
+      }
+
+      /* Sidebar Styles */
+      aside {
+        width: 300px;
+        background-color: var(--sidebar-bg);
+        border-right: 1px solid var(--border);
+        display: flex;
+        flex-direction: column;
+        padding: 1.5rem;
+        flex-shrink: 0;
+        transition: transform 0.3s ease;
+      }
+
+      .logo {
+        font-size: 1.5rem;
+        font-weight: 700;
+        margin-bottom: 2rem;
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        color: var(--accent);
+      }
+
+      .new-chat-btn {
+        background: var(--accent);
+        color: white;
+        border: none;
+        padding: 0.8rem;
+        border-radius: 0.5rem;
+        cursor: pointer;
+        font-weight: 600;
+        margin-bottom: 1.5rem;
+        transition: all 0.2s;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 0.5rem;
+      }
+
+      .new-chat-btn:hover {
+        background: var(--accent-hover);
+        transform: translateY(-1px);
+      }
+
+      .history-list {
+        flex: 1;
+        overflow-y: auto;
+        display: flex;
+        flex-direction: column;
+        gap: 0.5rem;
+      }
+
+      .history-item {
+        padding: 0.75rem;
+        border-radius: 0.4rem;
+        cursor: pointer;
+        transition: background 0.2s;
+        font-size: 0.9rem;
+        color: var(--text-secondary);
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        border: 1px solid transparent;
+      }
+
+      .history-item:hover {
+        background: var(--glass-bg);
+        color: var(--text-primary);
+        border-color: var(--border);
+      }
+
+      .history-item.active {
+        background: rgba(99, 102, 241, 0.15);
+        color: var(--accent);
+        border-color: rgba(99, 102, 241, 0.3);
+      }
+
+      /* Main Content Styles */
+      main {
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        position: relative;
+        background: radial-gradient(
+          circle at bottom right,
+          rgba(99, 102, 241, 0.05),
+          transparent
+        );
+      }
+
+      header {
+        height: 60px;
+        border-bottom: 1px solid var(--border);
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 0 2rem;
+        background: rgba(15, 17, 23, 0.8);
+        backdrop-filter: blur(8px);
+        z-index: 10;
+      }
+
+      .blog-actions {
+        display: flex;
+        gap: 1rem;
+      }
+
+      .btn-icon {
+        background: transparent;
+        border: 1px solid var(--border);
+        color: var(--text-secondary);
+        padding: 0.5rem;
+        border-radius: 0.4rem;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        gap: 0.4rem;
+        font-weight: 500;
+        transition: all 0.2s;
+      }
+
+      .btn-icon:hover:not(:disabled) {
+        background: var(--glass-bg);
+        color: var(--text-primary);
+        border-color: var(--text-secondary);
+      }
+
+      .btn-delete:hover:not(:disabled) {
+        background: rgba(239, 68, 68, 0.1);
+        color: #ef4444;
+        border-color: rgba(239, 68, 68, 0.3);
+      }
+
+      /* Chat/Content Area */
+      #content-area {
+        flex: 1;
+        overflow-y: auto;
+        padding: 2rem;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+      }
+
+      .welcome-screen {
+        height: 100%;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+        align-items: center;
+        text-align: center;
+        max-width: 600px;
+      }
+
+      .welcome-screen h1 {
+        font-size: 2.5rem;
+        margin-bottom: 1rem;
+        background: linear-gradient(to right, #818cf8, #6366f1);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+      }
+
+      .welcome-screen p {
+        color: var(--text-secondary);
+        font-size: 1.1rem;
+        line-height: 1.6;
+      }
+
+      /* Markdown Display */
+      .markdown-body {
+        width: 100%;
+        max-width: 800px;
+        color: var(--text-primary);
+        line-height: 1.7;
+        display: none;
+      }
+
+      .markdown-body h1,
+      .markdown-body h2,
+      .markdown-body h3 {
+        margin-top: 2rem;
+        margin-bottom: 1rem;
+        color: white;
+      }
+
+      .markdown-body p {
+        margin-bottom: 1rem;
+      }
+      .markdown-body img {
+        max-width: 100%;
+        border-radius: 0.8rem;
+        margin: 2rem 0;
+        box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
+      }
+
+      .markdown-body pre {
+        background: #1e1e1e;
+        padding: 1.5rem;
+        border-radius: 0.8rem;
+        overflow-x: auto;
+        margin-bottom: 1.5rem;
+        border: 1px solid var(--border);
+      }
+
+      /* Pipeline Progression (Console) */
+      #pipeline-status {
+        width: 100%;
+        max-width: 800px;
+        background: #000;
+        color: #10b981;
+        font-family: "Courier New", Courier, monospace;
+        padding: 1.5rem;
+        border-radius: 0.8rem;
+        margin-bottom: 2rem;
+        font-size: 0.9rem;
+        display: none;
+        border: 1px solid #10b98133;
+        max-height: 400px;
+        overflow-y: auto;
+        box-shadow: 0 0 20px rgba(16, 185, 129, 0.1);
+      }
+
+      .status-line {
+        margin-bottom: 0.5rem;
+        animation: fadeIn 0.3s ease-out;
+      }
+
+      @keyframes fadeIn {
+        from {
+          opacity: 0;
+          transform: translateY(5px);
+        }
+        to {
+          opacity: 1;
+          transform: translateY(0);
+        }
+      }
+
+      /* Input Area at the bottom */
+      .input-container {
+        padding: 2rem;
+        width: 100%;
+        display: flex;
+        justify-content: center;
+      }
+
+      .input-wrapper {
+        max-width: 800px;
+        width: 100%;
+        position: relative;
+        background: var(--glass-bg);
+        border: 1px solid var(--border);
+        border-radius: 1rem;
+        padding: 0.5rem;
+        display: flex;
+        align-items: center;
+        transition: all 0.3s;
+      }
+
+      .input-wrapper:focus-within {
+        border-color: var(--accent);
+        background: rgba(255, 255, 255, 0.05);
+        box-shadow: 0 0 0 2px rgba(99, 102, 241, 0.1);
+      }
+
+      input {
+        flex: 1;
+        background: transparent;
+        border: none;
+        color: white;
+        padding: 0.75rem 1rem;
+        outline: none;
+        font-size: 1rem;
+      }
+
+      .send-btn {
+        background: var(--accent);
+        color: white;
+        border: none;
+        width: 40px;
+        height: 40px;
+        border-radius: 0.5rem;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: all 0.2s;
+      }
+
+      .send-btn:hover {
+        background: var(--accent-hover);
+      }
+
+      .send-btn:disabled {
+        background: var(--text-secondary);
+        cursor: not-allowed;
+        opacity: 0.5;
+      }
+
+      /* Loading Spinner */
+      .spinner {
+        width: 20px;
+        height: 20px;
+        border: 2px solid rgba(255, 255, 255, 0.3);
+        border-radius: 50%;
+        border-top-color: white;
+        animation: spin 0.8s linear infinite;
+      }
+
+      @keyframes spin {
+        to {
+          transform: rotate(360deg);
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <aside>
+      <div class="logo">
+        <svg
+          width="24"
+          height="24"
+          viewBox="0 0 24 24"
+          fill="none"
+          stroke="currentColor"
+          stroke-width="2"
+          stroke-linecap="round"
+          stroke-linejoin="round"
+        >
+          <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+          <polyline points="7 10 12 15 17 10" />
+          <line x1="12" y1="15" x2="12" y2="3" />
+        </svg>
+        Bloggig
+      </div>
+      <button class="new-chat-btn" onclick="startNewBlog()">
+        <svg
+          width="20"
+          height="20"
+          viewBox="0 0 24 24"
+          fill="none"
+          stroke="currentColor"
+          stroke-width="2"
+          stroke-linecap="round"
+          stroke-linejoin="round"
+        >
+          <line x1="12" y1="5" x2="12" y2="19" />
+          <line x1="5" y1="12" x2="19" y2="12" />
+        </svg>
+        New Blog
+      </button>
+      <div class="history-list" id="history-container">
+        <!-- Blogs will be loaded here -->
+      </div>
+    </aside>
+
+    <main>
+      <header>
+        <div id="blog-title-display" style="font-weight: 600">
+          Blog Overview
+        </div>
+        <div class="blog-actions">
+          <button
+            class="btn-icon"
+            id="download-btn"
+            onclick="downloadCurrentBlog()"
+            disabled
+          >
+            <svg
+              width="18"
+              height="18"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            >
+              <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+              <polyline points="7 10 12 15 17 10" />
+              <line x1="12" y1="15" x2="12" y2="3" />
+            </svg>
+            Download
+          </button>
+          <button
+            class="btn-icon btn-delete"
+            id="delete-btn"
+            onclick="deleteCurrentBlog()"
+            disabled
+          >
+            <svg
+              width="18"
+              height="18"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            >
+              <polyline points="3 6 5 6 21 6" />
+              <path
+                d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"
+              />
+              <line x1="10" y1="11" x2="10" y2="17" />
+              <line x1="14" y1="11" x2="14" y2="17" />
+            </svg>
+            Delete
+          </button>
+        </div>
+      </header>
+
+      <div id="content-area">
+        <div class="welcome-screen" id="welcome-screen">
+          <h1>Craft something amazing.</h1>
+          <p>
+            Welcome to Bloggig. Enter a topic below to start generating a
+            high-quality, research-backed blog post with AI-generated visuals.
+          </p>
+        </div>
+
+        <div id="pipeline-status"></div>
+        <div class="markdown-body" id="blog-content"></div>
+      </div>
+
+      <div class="input-container">
+        <div class="input-wrapper">
+          <input
+            type="text"
+            id="topic-input"
+            placeholder="Enter blog topic..."
+            onkeypress="if (event.key === 'Enter') startGeneration();"
+          />
+          <button
+            class="send-btn"
+            id="generate-btn"
+            onclick="startGeneration()"
+          >
+            <svg
+              id="send-icon"
+              width="20"
+              height="20"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            >
+              <line x1="22" y1="2" x2="11" y2="13" />
+              <polyline points="22 2 15 22 11 13 2 9 22 2" />
+            </svg>
+          </button>
+        </div>
+      </div>
+    </main>
+
+    <script>
+      let currentBlogData = null;
+      let isGenerating = false;
+
+      // Initialize marked and highlight.js
+      marked.setOptions({
+        highlight: function (code, lang) {
+          if (lang && hljs.getLanguage(lang)) {
+            return hljs.highlight(code, { language: lang }).value;
+          }
+          return hljs.highlightAuto(code).value;
+        },
+        breaks: true,
+      });
+
+      async function loadHistory() {
+        const res = await fetch("/blogs");
+        const blogs = await res.json();
+        const container = document.getElementById("history-container");
+        container.innerHTML = "";
+
+        blogs.forEach((title) => {
+          const div = document.createElement("div");
+          div.className = "history-item";
+          div.textContent = title;
+          div.onclick = () => loadBlog(title);
+          container.appendChild(div);
+        });
+      }
+
+      async function loadBlog(title) {
+        if (isGenerating) return;
+
+        const res = await fetch(`/blog/${encodeURIComponent(title)}`);
+        if (!res.ok) return;
+
+        const data = await res.json();
+        currentBlogData = {
+          topic: title,
+          plan: { blog_title: title },
+          final: data.content,
+        };
+
+        displayBlog(data.content);
+        document.getElementById("blog-title-display").textContent = title;
+
+        // Mark as active in sidebar
+        document.querySelectorAll(".history-item").forEach((item) => {
+          item.classList.toggle("active", item.textContent === title);
+        });
+
+        // Enable actions
+        document.getElementById("download-btn").disabled = false;
+        document.getElementById("delete-btn").disabled = false;
+      }
+
+      function displayBlog(markdown) {
+        const blogContent = document.getElementById("blog-content");
+        const welcome = document.getElementById("welcome-screen");
+        const pipeline = document.getElementById("pipeline-status");
+
+        welcome.style.display = "none";
+        pipeline.style.display = "none";
+        blogContent.style.display = "block";
+
+        // Rewrite image paths to use the /images static mount if they are internal
+        const processedMd = markdown.replace(/\(\.\.\/images\//g, "(/images/");
+
+        blogContent.innerHTML = marked.parse(processedMd);
+        hljs.highlightAll();
+      }
+
+      function startNewBlog() {
+        if (isGenerating) return;
+
+        currentBlogData = null;
+        document.getElementById("welcome-screen").style.display = "flex";
+        document.getElementById("blog-content").style.display = "none";
+        document.getElementById("pipeline-status").style.display = "none";
+        document.getElementById("blog-title-display").textContent =
+          "Blog Overview";
+        document.getElementById("topic-input").value = "";
+        document.getElementById("download-btn").disabled = true;
+        document.getElementById("delete-btn").disabled = true;
+
+        document.querySelectorAll(".history-item").forEach((item) => {
+          item.classList.remove("active");
+        });
+      }
+
+      function appendStatus(msg) {
+        const pipeline = document.getElementById("pipeline-status");
+        pipeline.style.display = "block";
+        const line = document.createElement("div");
+        line.className = "status-line";
+        line.innerHTML = `<span style="color: #6ee7b7;">[${new Date().toLocaleTimeString()}]</span> ${msg}`;
+        pipeline.appendChild(line);
+        pipeline.scrollTop = pipeline.scrollHeight;
+      }
+
+      function startGeneration() {
+        const topicInput = document.getElementById("topic-input");
+        const topic = topicInput.value.trim();
+        if (!topic || isGenerating) return;
+
+        isGenerating = true;
+        setLoading(true);
+
+        document.getElementById("welcome-screen").style.display = "none";
+        document.getElementById("blog-content").style.display = "none";
+        const pipeline = document.getElementById("pipeline-status");
+        pipeline.innerHTML = "";
+        pipeline.style.display = "block";
+
+        appendStatus(`Initializing generation for topic: "${topic}"...`);
+
+        const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+        const ws = new WebSocket(
+          `${protocol}//${window.location.host}/ws/generate_blog`,
+        );
+
+        ws.onopen = () => {
+          ws.send(JSON.stringify({ topic }));
+        };
+
+        ws.onmessage = (event) => {
+          const data = JSON.parse(event.data);
+
+          if (data.status === "completed") {
+            appendStatus("Done! Finalizing blog post...");
+          } else if (data.final) {
+            // This is the final state
+            currentBlogData = data;
+            displayBlog(data.final);
+            loadHistory(); // Refresh history
+            setLoading(false);
+            isGenerating = false;
+            document.getElementById("download-btn").disabled = false;
+            document.getElementById("delete-btn").disabled = false;
+            if (data.plan && data.plan.blog_title) {
+              document.getElementById("blog-title-display").textContent =
+                data.plan.blog_title;
+            }
+          } else if (data.error) {
+            appendStatus(
+              `<span style="color: #f87171;">ERROR: ${data.error}</span>`,
+            );
+            setLoading(false);
+            isGenerating = false;
+          } else {
+            // Try to infer what happened from the state keys
+            if (data.sections && data.sections.length > 0) {
+              const lastSection = data.sections[data.sections.length - 1];
+              appendStatus(
+                `Generated section: ${lastSection[1].split("\n")[0].replace("## ", "")}`,
+              );
+            } else if (data.plan) {
+              appendStatus(
+                `Plan created: "${data.plan.blog_title}" with ${data.plan.tasks.length} sections.`,
+              );
+            } else if (data.queries && data.queries.length > 0) {
+              appendStatus(`Researching: ${data.queries.join(", ")}`);
+            }
+          }
+        };
+
+        ws.onerror = (err) => {
+          appendStatus(
+            `<span style="color: #f87171;">Connection error.</span>`,
+          );
+          setLoading(false);
+          isGenerating = false;
+        };
+
+        ws.onclose = () => {
+          if (isGenerating) {
+            appendStatus("Connection closed.");
+            setLoading(false);
+            isGenerating = false;
+          }
+        };
+      }
+
+      function setLoading(loading) {
+        const btn = document.getElementById("generate-btn");
+        const icon = document.getElementById("send-icon");
+        if (loading) {
+          btn.disabled = true;
+          btn.innerHTML = '<div class="spinner"></div>';
+        } else {
+          btn.disabled = false;
+          btn.innerHTML = `<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="22" y1="2" x2="11" y2="13"/><polyline points="22 2 15 22 11 13 2 9 22 2"/></svg>`;
+        }
+      }
+
+      async function deleteCurrentBlog() {
+        if (
+          !currentBlogData ||
+          !confirm(
+            "Are you sure you want to delete this blog and all related images?",
+          )
+        )
+          return;
+
+        const res = await fetch("/delete_blog", {
+          method: "DELETE",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ data: currentBlogData }),
+        });
+
+        if (res.ok) {
+          startNewBlog();
+          loadHistory();
+        } else {
+          alert("Failed to delete blog.");
+        }
+      }
+
+      function downloadCurrentBlog() {
+        if (!currentBlogData) return;
+        const title = currentBlogData.plan
+          ? currentBlogData.plan.blog_title
+          : currentBlogData.topic;
+        window.location.href = `/download_blog/${encodeURIComponent(title)}`;
+      }
+
+      // Initial history load
+      loadHistory();
+    </script>
+  </body>
+</html>

credentials_example.yaml

@@ -0,0 +1,5 @@
+# Rename this file to credentials.yaml to be able to run the scripts
+
+url: "https://us-south.ml.cloud.ibm.com"
+apikey: ""
+space_id: ""

data/README.md

@@ -0,0 +1,3 @@
+# Data
+
+Here goes the data for the project, such as training datasets. When using DVC, it should point at this folder

deployment-setup-notes.txt

@@ -0,0 +1,177 @@
+===============================
+EC2 FastAPI Deployment Notes
+===============================
+
+PROJECT: Blog Writing Agent
+STACK: FastAPI + uv + systemd + GitHub Actions CI/CD
+
+
+--------------------------------------------------
+1️⃣ Create systemd Service File
+--------------------------------------------------
+
+Command:
+sudo nano /etc/systemd/system/blog-agent.service
+
+Why?
+- /etc/systemd/system/ is system-level directory
+- Normal user cannot create files here
+- sudo required for admin access
+- This file defines how our app runs as a service
+
+
+--------------------------------------------------
+2️⃣ Service File Content
+--------------------------------------------------
+
+[Unit]
+Description=Blog Agent FastAPI App
+After=network.target
+
+[Service]
+User=ubuntu
+WorkingDirectory=/var/www/blog-agent
+ExecStart=/home/ubuntu/.local/bin/uv run uvicorn Application.app:app --host 0.0.0.0 --port 8000
+Restart=always
+
+[Install]
+WantedBy=multi-user.target
+
+
+Why each line?
+
+User=ubuntu
+→ Runs app as ubuntu user (safer than root)
+
+WorkingDirectory
+→ Tells system where project exists
+
+ExecStart
+→ Exact command to start FastAPI app
+
+Restart=always
+→ If app crashes, systemd restarts it automatically
+
+WantedBy=multi-user.target
+→ Makes service start when system boots
+
+
+--------------------------------------------------
+3️⃣ Reload systemd
+--------------------------------------------------
+
+Command:
+sudo systemctl daemon-reload
+
+Why?
+- After creating new service file
+- systemd must reload configuration
+- Otherwise it won’t detect new service
+
+
+--------------------------------------------------
+4️⃣ Enable Service (Auto Start on Reboot)
+--------------------------------------------------
+
+Command:
+sudo systemctl enable blog-agent
+
+Why?
+- Makes app start automatically when server reboots
+- Without this, service won’t auto start
+
+
+--------------------------------------------------
+5️⃣ Start Service
+--------------------------------------------------
+
+Command:
+sudo systemctl start blog-agent
+
+Why?
+- Immediately start app without reboot
+
+
+--------------------------------------------------
+6️⃣ Check Status
+--------------------------------------------------
+
+Command:
+sudo systemctl status blog-agent
+
+Why?
+- Verify if service is running
+- Shows logs and errors if any
+
+
+--------------------------------------------------
+7️⃣ Restart During Deployment (Used in CD)
+--------------------------------------------------
+
+Command:
+sudo systemctl restart blog-agent
+
+Why?
+- After git pull & uv sync
+- Restart loads latest code
+- Clean exit code (no 143 error)
+- GitHub Actions shows GREEN ✔
+
+
+--------------------------------------------------
+🚀 Why We Stopped Using nohup & ?
+--------------------------------------------------
+
+Problem:
+- SSH session close → background process killed
+- GitHub showed "Process exited with status 143"
+- Deployment looked failed even though server updated
+
+Solution:
+- Use systemd service
+- App runs independently of SSH
+- Clean process management
+- Production ready setup
+
+
+--------------------------------------------------
+🎯 Final Deployment Flow
+--------------------------------------------------
+
+GitHub Push
+   ↓
+CI Run (Tests)
+   ↓
+CD SSH into EC2
+   ↓
+git pull origin main
+uv sync
+sudo systemctl restart blog-agent
+   ↓
+App Updated Successfully
+
+
+--------------------------------------------------
+🔥 Important Concepts Learned
+--------------------------------------------------
+
+✔ Difference between normal user & root
+✔ What sudo does
+✔ What systemd is
+✔ Why production apps use services
+✔ Why background (&, nohup) is not production safe
+✔ Why exit code 143 happens
+✔ Proper CI/CD deployment architecture
+
+
+--------------------------------------------------
+🏆 Result
+--------------------------------------------------
+
+App:
+- Auto restarts if crashed
+- Auto starts on server reboot
+- Independent of SSH
+- Clean GitHub deployment (Green tick)
+
+Production-level deployment achieved.

docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+  app:
+    build: .
+    image: bloggingagent:latest
+    ports:
+      - "7860:7860"
+    env_file:
+      - .env
+    volumes:
+      - ./images:/app/images
+      - ./results:/app/results
+      - ./logs:/app/logs
+    restart: always
+
+# Ensure directories exist for volume mapping
+# Note: Docker will create them as root if they don't exist,
+# but the app might need write permissions.

jenkinsfile

@@ -0,0 +1,105 @@
+pipeline {
+    agent any
+
+    environment {
+        REPO_URL = "https://github.com/VashuTheGreat/Blog-Writing-Agent.git"
+        PROJECT_NAME = "Blog-Writing-Agent"
+        SPACE_NAME="Blog-Writing-Agent"
+        HF_USERNAME="VashuTheGreat2"
+        HF_TOKEN = credentials('HF_TOKEN')
+
+    }
+
+    stages {
+
+        stage('Clone Repository') {
+            steps {
+                echo "📥 Cloning repository..."
+                git branch: 'main', url: "${REPO_URL}"
+            }
+        }
+
+        stage('Setup Dependencies') {
+            steps {
+                echo "🔧 Setting git identity and installing HF CLI..."
+                sh '''#!/bin/bash
+set -e
+git config --global user.name "jenkins"
+git config --global user.email "jenkins@local"
+export PATH=$HOME/.local/bin:$PATH
+if ! command -v hf &> /dev/null; then
+    pip3 install --user -U huggingface_hub
+fi
+'''
+            }
+        }
+
+        stage('Authenticate Hugging Face') {
+            steps {
+                echo "🔐 Logging into Hugging Face..."
+                sh '''#!/bin/bash
+set -e
+export PATH=$HOME/.local/bin:$PATH
+hf auth login --token "$HF_TOKEN"
+'''
+            }
+        }
+
+        stage('Configure Space Meta') {
+            steps {
+                echo "📝 Injecting HF Spaces configuration into README.md..."
+                sh '''#!/bin/bash
+set -e
+TEMP_README=$(mktemp)
+cat << EOF > "$TEMP_README"
+---
+title: $PROJECT_NAME
+emoji: 🎓
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_file: main.py
+pinned: false
+short_description: This is the Agentic Blog Writing Agent
+---
+
+EOF
+cat README.md >> "$TEMP_README"
+mv "$TEMP_README" README.md
+'''
+            }
+        }
+
+        stage('Create App Space') {
+            steps {
+                echo "🚀 Creating HF Space if it doesn't exist..."
+                sh '''#!/bin/bash
+set -e
+export PATH=$HOME/.local/bin:$PATH
+hf repos create "$HF_USERNAME/$SPACE_NAME" --type space --space-sdk docker || true
+'''
+            }
+        }
+
+        stage('Upload to HF Space') {
+            steps {
+                echo "📤 Uploading project files..."
+                sh '''#!/bin/bash
+set -e
+export PATH=$HOME/.local/bin:$PATH
+hf upload "$HF_USERNAME/$SPACE_NAME" . --repo-type=space
+'''
+            }
+        }
+
+    }
+
+    post {
+        success {
+            echo "✅ Pipeline executed successfully!"
+        }
+        failure {
+            echo "❌ Pipeline failed!"
+        }
+    }
+}

main.py

@@ -0,0 +1,10 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from src.logger import *
+from api.app import app
+
+
+if __name__=="__main__":
+    import uvicorn as uv
+    uv.run("main:app",host="0.0.0.0",port=7860,reload=True)

metadata.yaml

@@ -0,0 +1,4 @@
+author: Vansh
+model_type: scikit-learn_0.23
+project_name: blogging_agent
+project_version: v0.1

models/README.md

@@ -0,0 +1,3 @@
+# Models
+
+Here goes the trained models. DVC should use this models in versioning

notebooks/README.md

@@ -0,0 +1,3 @@
+# Notebooks
+
+Here goes the notebooks used for research and development.

notebooks/image_placeHolder.ipynb

@@ -0,0 +1,376 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0b9ffe5f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pydantic import BaseModel,Field\n",
+    "from typing import Literal,List\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "cd7bb64d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from dotenv import load_dotenv\n",
+    "load_dotenv()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "dd8207ef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ImageSpec(BaseModel):\n",
+    "    placeholder:str=Field(...,description=\"e.g. [[IMAGE_1]]\")\n",
+    "    filename:str=Field(...,description=\"Save under images/, e.g. qkv_flow.png\")\n",
+    "    prompt:str=Field(...,description=\"Prompt to send to the image model\")\n",
+    "    size:Literal[\"1024x1024\",\"1024x1536\",\"1536x1024\"]=\"1025x1024\"\n",
+    "    quality: Literal[\"low\", \"medium\", \"high\"] = \"medium\"\n",
+    "\n",
+    "\n",
+    "class GlobalImagePlan(BaseModel):\n",
+    "    md_with_placeholders:str\n",
+    "    images:List[ImageSpec]=Field(default_factory=list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "63f25031",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_aws import ChatBedrockConverse\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "255a2613",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "LLM_MODEL_ID = \"us.meta.llama3-3-70b-instruct-v1:0\"\n",
+    "LLM_REGION = \"us-east-1\"\n",
+    "llm = ChatBedrockConverse(\n",
+    "    model_id=LLM_MODEL_ID,\n",
+    "    region_name=LLM_REGION\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "849c528a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "placehonder=\"\"\"You are an expert technical blog image planning assistant.\n",
+    "\n",
+    "Your job is to analyze a Markdown blog post and generate a structured image plan.\n",
+    "\n",
+    "You MUST return output strictly matching the Pydantic model `GlobalImagePlan`.\n",
+    "\n",
+    "-----------------------------------------\n",
+    "YOUR TASK\n",
+    "-----------------------------------------\n",
+    "\n",
+    "You will receive a Markdown blog as input.\n",
+    "\n",
+    "You must:\n",
+    "\n",
+    "1. Keep the Markdown EXACTLY the same.\n",
+    "2. DO NOT rewrite, summarize, improve, or modify any text.\n",
+    "3. DO NOT remove or change any formatting.\n",
+    "4. Only insert image placeholders where images would improve clarity.\n",
+    "\n",
+    "-----------------------------------------\n",
+    "WHERE TO INSERT IMAGES\n",
+    "-----------------------------------------\n",
+    "\n",
+    "Insert placeholders only:\n",
+    "- After major section headings (## or ###)\n",
+    "- After complex explanations\n",
+    "- After architecture descriptions\n",
+    "- After workflows\n",
+    "- After comparisons\n",
+    "- Where diagrams would help understanding\n",
+    "- Where visual examples would add clarity\n",
+    "\n",
+    "DO NOT:\n",
+    "- Add images randomly\n",
+    "- Add too many images\n",
+    "- Break code blocks\n",
+    "- Insert placeholders inside code blocks\n",
+    "- Modify existing content\n",
+    "\n",
+    "-----------------------------------------\n",
+    "PLACEHOLDER FORMAT\n",
+    "-----------------------------------------\n",
+    "\n",
+    "Use this exact format:\n",
+    "\n",
+    "[[IMAGE_1]]\n",
+    "[[IMAGE_2]]\n",
+    "[[IMAGE_3]]\n",
+    "\n",
+    "Number them sequentially.\n",
+    "\n",
+    "-----------------------------------------\n",
+    "IMAGE SPEC RULES\n",
+    "-----------------------------------------\n",
+    "\n",
+    "For each placeholder generate an ImageSpec with:\n",
+    "\n",
+    "- placeholder: exact placeholder string (e.g. [[IMAGE_1]])\n",
+    "- filename: save under images/ directory (example: images/attention_flow.png)\n",
+    "- prompt: highly detailed image generation prompt describing what the image should show\n",
+    "- size: choose one of:\n",
+    "    - 1024x1024 (for square diagrams)\n",
+    "    - 1536x1024 (for wide architecture diagrams)\n",
+    "    - 1024x1536 (for vertical infographics)\n",
+    "- quality: \"medium\" unless diagram is complex → use \"high\"\n",
+    "\n",
+    "The prompt must:\n",
+    "- Be descriptive\n",
+    "- Mention diagram style\n",
+    "- Mention labels\n",
+    "- Mention arrows and flow\n",
+    "- Mention clean white background\n",
+    "- Mention professional technical illustration style\n",
+    "\n",
+    "-----------------------------------------\n",
+    "IMPORTANT OUTPUT RULES\n",
+    "-----------------------------------------\n",
+    "\n",
+    "You MUST return ONLY a valid GlobalImagePlan JSON object.\n",
+    "\n",
+    "Do NOT include:\n",
+    "- Explanations\n",
+    "- Extra text\n",
+    "- Markdown fences\n",
+    "- Comments\n",
+    "- Any text before or after the JSON\n",
+    "\n",
+    "-----------------------------------------\n",
+    "OUTPUT FORMAT\n",
+    "-----------------------------------------\n",
+    "\n",
+    "{\n",
+    "  \"md_with_placeholders\": \"...full markdown with inserted placeholders...\",\n",
+    "  \"images\": [\n",
+    "    {\n",
+    "      \"placeholder\": \"[[IMAGE_1]]\",\n",
+    "      \"filename\": \"images/example.png\",\n",
+    "      \"prompt\": \"Detailed image generation prompt...\",\n",
+    "      \"size\": \"1536x1024\",\n",
+    "      \"quality\": \"medium\"\n",
+    "    }\n",
+    "  ]\n",
+    "}\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "332e03d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.messages import SystemMessage,HumanMessage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "1a7a4167",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "markdown=\"\"\"\n",
+    "# State of Multimodal LLMs in 2026\n",
+    "\n",
+    "## Introduction to Multimodal LLMs\n",
+    "Recent developments in multimodal LLMs have shown significant progress, with models now capable of processing and generating multiple forms of data, such as text, images, and audio [Not found in provided sources]. \n",
+    "* Multimodal LLMs have been applied to various tasks, including visual question answering, image captioning, and text-to-image synthesis.\n",
+    "* The impact of multimodal LLMs can be seen in industries like healthcare, education, and entertainment, where they are used for applications such as medical image analysis, interactive learning systems, and content creation [Not found in provided sources].\n",
+    "* Despite the advancements, key challenges in multimodal LLM research remain, including the need for large-scale datasets, improved model architectures, and better evaluation metrics [Not found in provided sources].\n",
+    "\n",
+    "## Recent Advances in Multimodal LLMs\n",
+    "Recent breakthroughs in multimodal LLM architecture have led to significant improvements in the field. \n",
+    "* Multimodal transformers, which combine visual and textual features, have shown promising results in tasks such as visual question answering and image-text retrieval [Not found in provided sources].\n",
+    "* The use of multimodal attention mechanisms has also been explored, allowing models to focus on specific parts of the input data [Not found in provided sources].\n",
+    "\n",
+    "Multimodal LLMs play a crucial role in both computer vision and natural language processing. \n",
+    "They can be used to analyze and understand visual data, such as images and videos, and generate text-based descriptions or summaries.\n",
+    "In natural language processing, multimodal LLMs can be used to improve language understanding and generation tasks, such as machine translation and text summarization.\n",
+    "\n",
+    "The potential applications of multimodal LLMs in healthcare are vast. \n",
+    "They can be used to analyze medical images, such as X-rays and MRIs, and generate text-based diagnoses or recommendations.\n",
+    "Additionally, multimodal LLMs can be used to develop personalized treatment plans and improve patient outcomes [Not found in provided sources].\n",
+    "Overall, the latest advancements in multimodal LLMs have the potential to revolutionize various fields, including healthcare, and improve the way we interact with and understand visual and textual data.\n",
+    "\n",
+    "## Challenges and Limitations\n",
+    "The development of multimodal LLMs has made significant progress, but there are still several challenges and limitations that need to be addressed. \n",
+    "* The limitations of current multimodal LLM models include their inability to fully understand the nuances of human communication, such as sarcasm, idioms, and figurative language [Not found in provided sources].\n",
+    "* Training and deploying multimodal LLMs pose significant challenges, including the need for large amounts of diverse and high-quality training data, as well as the requirement for significant computational resources [Not found in provided sources].\n",
+    "* Further research is needed to improve the performance and robustness of multimodal LLMs, particularly in areas such as common sense reasoning, emotional intelligence, and adaptability to new contexts and domains [Not found in provided sources]. \n",
+    "Overall, addressing these challenges and limitations will be crucial to unlocking the full potential of multimodal LLMs and achieving more effective and engaging human-computer interactions.\n",
+    "\n",
+    "## Future Directions\n",
+    "The future of multimodal LLMs holds great promise, with potential applications in areas such as [virtual assistants](Not found in provided sources) and [human-computer interaction](Not found in provided sources). \n",
+    "* Multimodal LLMs may be used to improve accessibility and user experience in various domains.\n",
+    "* The role of multimodal LLMs in shaping the future of AI is significant, as they can enable more natural and intuitive interactions between humans and machines.\n",
+    "* Continued research in multimodal LLMs is crucial to overcome current limitations and unlock their full potential, driving innovation and progress in the field of AI [Not found in provided sources].\n",
+    "\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "796739f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GlobalImagePlan(md_with_placeholders='# State of Multimodal LLMs in 2026\\n## Introduction to Multimodal LLMs\\nRecent developments in multimodal LLMs have shown significant progress, with models now capable of processing and generating multiple forms of data, such as text, images, and audio [Not found in provided sources]. \\n* Multimodal LLMs have been applied to various tasks, including visual question answering, image captioning, and text-to-image synthesis.\\n* The impact of multimodal LLMs can be seen in industries like healthcare, education, and entertainment, where they are used for applications such as medical image analysis, interactive learning systems, and content creation [Not found in provided sources].\\n* Despite the advancements, key challenges in multimodal LLM research remain, including the need for large-scale datasets, improved model architectures, and better evaluation metrics [Not found in provided sources].\\n[[IMAGE_1]]\\n## Recent Advances in Multimodal LLMs\\nRecent breakthroughs in multimodal LLM architecture have led to significant improvements in the field. \\n* Multimodal transformers, which combine visual and textual features, have shown promising results in tasks such as visual question answering and image-text retrieval [Not found in provided sources].\\n* The use of multimodal attention mechanisms has also been explored, allowing models to focus on specific parts of the input data [Not found in provided sources].\\n[[IMAGE_2]]\\nMultimodal LLMs play a crucial role in both computer vision and natural language processing. \\nThey can be used to analyze and understand visual data, such as images and videos, and generate text-based descriptions or summaries.\\nIn natural language processing, multimodal LLMs can be used to improve language understanding and generation tasks, such as machine translation and text summarization.\\n[[IMAGE_3]]\\nThe potential applications of multimodal LLMs in healthcare are vast. \\nThey can be used to analyze medical images, such as X-rays and MRIs, and generate text-based diagnoses or recommendations.\\nAdditionally, multimodal LLMs can be used to develop personalized treatment plans and improve patient outcomes [Not found in provided sources].\\nOverall, the latest advancements in multimodal LLMs have the potential to revolutionize various fields, including healthcare, and improve the way we interact with and understand visual and textual data.\\n[[IMAGE_4]]\\n## Challenges and Limitations\\nThe development of multimodal LLMs has made significant progress, but there are still several challenges and limitations that need to be addressed. \\n* The limitations of current multimodal LLM models include their inability to fully understand the nuances of human communication, such as sarcasm, idioms, and figurative language [Not found in provided sources].\\n* Training and deploying multimodal LLMs pose significant challenges, including the need for large amounts of diverse and high-quality training data, as well as the requirement for significant computational resources [Not found in provided sources].\\n* Further research is needed to improve the performance and robustness of multimodal LLMs, particularly in areas such as common sense reasoning, emotional intelligence, and adaptability to new contexts and domains [Not found in provided sources]. \\nOverall, addressing these challenges and limitations will be crucial to unlocking the full potential of multimodal LLMs and achieving more effective and engaging human-computer interactions.\\n[[IMAGE_5]]\\n## Future Directions\\nThe future of multimodal LLMs holds great promise, with potential applications in areas such as [virtual assistants](Not found in provided sources) and [human-computer interaction](Not found in provided sources). \\n* Multimodal LLMs may be used to improve accessibility and user experience in various domains.\\n* The role of multimodal LLMs in shaping the future of AI is significant, as they can enable more natural and intuitive interactions between humans and machines.\\n* Continued research in multimodal LLMs is crucial to overcome current limitations and unlock their full potential, driving innovation and progress in the field of AI [Not found in provided sources].\\n[[IMAGE_6]]', images=[ImageSpec(placeholder='[[IMAGE_1]]', filename='images/multimodal_llm_architecture.png', prompt='A diagram showing the architecture of a multimodal LLM, with visual and textual features combined, and labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style', size='1536x1024', quality='medium'), ImageSpec(placeholder='[[IMAGE_2]]', filename='images/multimodal_transformers.png', prompt='An illustration of multimodal transformers, with visual and textual features combined, and labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style', size='1024x1024', quality='medium'), ImageSpec(placeholder='[[IMAGE_3]]', filename='images/multimodal_llm_applications.png', prompt='A diagram showing the various applications of multimodal LLMs, including computer vision and natural language processing, with labels and arrows indicating the relationships between the different applications, on a clean white background, in a professional technical illustration style', size='1024x1536', quality='medium'), ImageSpec(placeholder='[[IMAGE_4]]', filename='images/multimodal_llm_healthcare.png', prompt='An illustration of the potential applications of multimodal LLMs in healthcare, including medical image analysis and personalized treatment plans, with labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style', size='1536x1024', quality='medium'), ImageSpec(placeholder='[[IMAGE_5]]', filename='images/multimodal_llm_challenges.png', prompt='A diagram showing the challenges and limitations of multimodal LLMs, including the need for large-scale datasets and improved model architectures, with labels and arrows indicating the relationships between the different challenges, on a clean white background, in a professional technical illustration style', size='1024x1024', quality='medium'), ImageSpec(placeholder='[[IMAGE_6]]', filename='images/multimodal_llm_future.png', prompt='An illustration of the future directions of multimodal LLMs, including potential applications in virtual assistants and human-computer interaction, with labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style', size='1024x1536', quality='medium')])"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "output=llm.with_structured_output(GlobalImagePlan)\\\n",
+    ".invoke(\n",
+    "    [\n",
+    "        SystemMessage(content=placehonder),\n",
+    "        HumanMessage(content=markdown)\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "0e44ffd5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'# State of Multimodal LLMs in 2026\\n## Introduction to Multimodal LLMs\\nRecent developments in multimodal LLMs have shown significant progress, with models now capable of processing and generating multiple forms of data, such as text, images, and audio [Not found in provided sources]. \\n* Multimodal LLMs have been applied to various tasks, including visual question answering, image captioning, and text-to-image synthesis.\\n* The impact of multimodal LLMs can be seen in industries like healthcare, education, and entertainment, where they are used for applications such as medical image analysis, interactive learning systems, and content creation [Not found in provided sources].\\n* Despite the advancements, key challenges in multimodal LLM research remain, including the need for large-scale datasets, improved model architectures, and better evaluation metrics [Not found in provided sources].\\n[[IMAGE_1]]\\n## Recent Advances in Multimodal LLMs\\nRecent breakthroughs in multimodal LLM architecture have led to significant improvements in the field. \\n* Multimodal transformers, which combine visual and textual features, have shown promising results in tasks such as visual question answering and image-text retrieval [Not found in provided sources].\\n* The use of multimodal attention mechanisms has also been explored, allowing models to focus on specific parts of the input data [Not found in provided sources].\\n[[IMAGE_2]]\\nMultimodal LLMs play a crucial role in both computer vision and natural language processing. \\nThey can be used to analyze and understand visual data, such as images and videos, and generate text-based descriptions or summaries.\\nIn natural language processing, multimodal LLMs can be used to improve language understanding and generation tasks, such as machine translation and text summarization.\\n[[IMAGE_3]]\\nThe potential applications of multimodal LLMs in healthcare are vast. \\nThey can be used to analyze medical images, such as X-rays and MRIs, and generate text-based diagnoses or recommendations.\\nAdditionally, multimodal LLMs can be used to develop personalized treatment plans and improve patient outcomes [Not found in provided sources].\\nOverall, the latest advancements in multimodal LLMs have the potential to revolutionize various fields, including healthcare, and improve the way we interact with and understand visual and textual data.\\n[[IMAGE_4]]\\n## Challenges and Limitations\\nThe development of multimodal LLMs has made significant progress, but there are still several challenges and limitations that need to be addressed. \\n* The limitations of current multimodal LLM models include their inability to fully understand the nuances of human communication, such as sarcasm, idioms, and figurative language [Not found in provided sources].\\n* Training and deploying multimodal LLMs pose significant challenges, including the need for large amounts of diverse and high-quality training data, as well as the requirement for significant computational resources [Not found in provided sources].\\n* Further research is needed to improve the performance and robustness of multimodal LLMs, particularly in areas such as common sense reasoning, emotional intelligence, and adaptability to new contexts and domains [Not found in provided sources]. \\nOverall, addressing these challenges and limitations will be crucial to unlocking the full potential of multimodal LLMs and achieving more effective and engaging human-computer interactions.\\n[[IMAGE_5]]\\n## Future Directions\\nThe future of multimodal LLMs holds great promise, with potential applications in areas such as [virtual assistants](Not found in provided sources) and [human-computer interaction](Not found in provided sources). \\n* Multimodal LLMs may be used to improve accessibility and user experience in various domains.\\n* The role of multimodal LLMs in shaping the future of AI is significant, as they can enable more natural and intuitive interactions between humans and machines.\\n* Continued research in multimodal LLMs is crucial to overcome current limitations and unlock their full potential, driving innovation and progress in the field of AI [Not found in provided sources].\\n[[IMAGE_6]]'"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "output.md_with_placeholders"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "00892f27",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[ImageSpec(placeholder='[[IMAGE_1]]', filename='images/multimodal_llm_architecture.png', prompt='A diagram showing the architecture of a multimodal LLM, with visual and textual features combined, and labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style', size='1536x1024', quality='medium'),\n",
+       " ImageSpec(placeholder='[[IMAGE_2]]', filename='images/multimodal_transformers.png', prompt='An illustration of multimodal transformers, with visual and textual features combined, and labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style', size='1024x1024', quality='medium'),\n",
+       " ImageSpec(placeholder='[[IMAGE_3]]', filename='images/multimodal_llm_applications.png', prompt='A diagram showing the various applications of multimodal LLMs, including computer vision and natural language processing, with labels and arrows indicating the relationships between the different applications, on a clean white background, in a professional technical illustration style', size='1024x1536', quality='medium'),\n",
+       " ImageSpec(placeholder='[[IMAGE_4]]', filename='images/multimodal_llm_healthcare.png', prompt='An illustration of the potential applications of multimodal LLMs in healthcare, including medical image analysis and personalized treatment plans, with labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style', size='1536x1024', quality='medium'),\n",
+       " ImageSpec(placeholder='[[IMAGE_5]]', filename='images/multimodal_llm_challenges.png', prompt='A diagram showing the challenges and limitations of multimodal LLMs, including the need for large-scale datasets and improved model architectures, with labels and arrows indicating the relationships between the different challenges, on a clean white background, in a professional technical illustration style', size='1024x1024', quality='medium'),\n",
+       " ImageSpec(placeholder='[[IMAGE_6]]', filename='images/multimodal_llm_future.png', prompt='An illustration of the future directions of multimodal LLMs, including potential applications in virtual assistants and human-computer interaction, with labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style', size='1024x1536', quality='medium')]"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "output.images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "0b4e77e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'A diagram showing the architecture of a multimodal LLM, with visual and textual features combined, and labels and arrows indicating the flow of data, on a clean white background, in a professional technical illustration style'"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "output.images[0].prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8666fa58",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "bloggig-Agent (3.12.12)",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/understanding_self_attention.md

@@ -0,0 +1,120 @@
+# Understanding Self Attention
+
+### Introduction to Self Attention
+Self-attention, also known as intra-attention, is a mechanism used in deep learning models to allow the model to attend to different parts of the input data and weigh their importance. It's a key component of the Transformer architecture, introduced in 2017, which revolutionized the field of natural language processing (NLP). Self-attention enables the model to capture long-range dependencies and contextual relationships in the input data, making it particularly useful for sequence-to-sequence tasks such as machine translation, text summarization, and chatbots. The importance of self-attention lies in its ability to handle variable-length input sequences, parallelize computation, and improve model performance by focusing on the most relevant parts of the input data. In this blog, we'll delve deeper into the concept of self-attention, its types, and its applications in deep learning.
+
+### How Self Attention Works
+Self-attention is a mechanism that allows a model to attend to different parts of the input sequence simultaneously and weigh their importance. It's a key component of the Transformer architecture, introduced in the paper "Attention is All You Need" by Vaswani et al.
+
+The self-attention mechanism takes in a set of input vectors, typically the output of an encoder or a previous layer, and computes a weighted sum of these vectors based on their similarity. The weights are learned during training and reflect the relative importance of each input vector.
+
+The mathematical formulation of self-attention can be broken down into three main steps:
+
+1. **Query, Key, and Value Vectors**: The input vectors are first transformed into three different vectors: Query (Q), Key (K), and Value (V). These vectors are obtained by applying linear transformations to the input vectors.
+2. **Attention Scores**: The attention scores are computed by taking the dot product of the Query and Key vectors and applying a scaling factor. The attention scores represent the similarity between the input vectors.
+3. **Weighted Sum**: The attention scores are then used to compute a weighted sum of the Value vectors. The weighted sum is the final output of the self-attention mechanism.
+
+The self-attention mechanism can be formulated mathematically as follows:
+
+`Attention(Q, K, V) = softmax(Q * K^T / sqrt(d)) * V`
+
+where `Q`, `K`, and `V` are the Query, Key, and Value vectors, respectively, `d` is the dimensionality of the input vectors, and `softmax` is the softmax activation function.
+
+The self-attention mechanism has several benefits, including:
+
+* **Parallelization**: Self-attention can be parallelized more easily than recurrent neural networks (RNNs), making it more efficient for long-range dependencies.
+* **Flexibility**: Self-attention can handle variable-length input sequences and can be used for both encoding and decoding tasks.
+* **Interpretability**: The attention scores can provide insights into which parts of the input sequence are most relevant for a particular task.
+
+### Types of Self Attention
+There are several types of self-attention mechanisms that have been proposed in the literature, each with its own strengths and weaknesses. The two main categories of self-attention are local self-attention and global self-attention.
+
+#### Local Self Attention
+Local self-attention, also known as local attention or window-based attention, focuses on a fixed-size window of the input sequence. This type of attention is useful when the relationships between nearby elements in the sequence are more important than the relationships between distant elements. Local self-attention is often used in tasks such as language modeling and machine translation.
+
+#### Global Self Attention
+Global self-attention, on the other hand, considers the entire input sequence when computing the attention weights. This type of attention is useful when the relationships between all elements in the sequence are important, regardless of their distance. Global self-attention is often used in tasks such as question answering and text classification.
+
+#### Other Types of Self Attention
+In addition to local and global self-attention, there are other variants of self-attention that have been proposed, including:
+* **Hierarchical self-attention**: This type of attention uses a hierarchical representation of the input sequence, where the attention weights are computed at multiple levels of granularity.
+* **Graph-based self-attention**: This type of attention is used for graph-structured data, where the attention weights are computed based on the graph structure.
+* **Multi-head self-attention**: This type of attention uses multiple attention heads to capture different types of relationships between the elements in the input sequence.
+
+### Applications of Self Attention
+Self-attention has numerous applications across various fields, including natural language processing, computer vision, and more. Some of the key applications of self-attention are:
+* **Natural Language Processing (NLP)**: Self-attention is widely used in NLP tasks such as language translation, question answering, and text summarization. It helps in understanding the context and relationships between different words in a sentence.
+* **Computer Vision**: Self-attention is used in computer vision tasks such as image classification, object detection, and image generation. It helps in understanding the relationships between different parts of an image.
+* **Speech Recognition**: Self-attention is used in speech recognition tasks to improve the accuracy of speech-to-text models.
+* **Recommendation Systems**: Self-attention is used in recommendation systems to understand the relationships between different items and recommend relevant items to users.
+* **Time Series Forecasting**: Self-attention is used in time series forecasting to understand the relationships between different time steps and predict future values.
+The use of self-attention has led to state-of-the-art results in many of these applications, and its potential continues to be explored in other fields.
+
+### Implementing Self Attention
+Implementing self-attention in a deep learning model involves several key steps. Here's a step-by-step guide to help you get started:
+#### Step 1: Define the Self-Attention Mechanism
+The self-attention mechanism is based on the Query-Key-Value (QKV) framework. You need to define the QKV matrices and calculate the attention weights using the following formula: 
+$$Attention(Q, K, V) = softmax(\frac{Q \cdot K^T}{\sqrt{d_k}}) \cdot V$$
+where $d_k$ is the dimensionality of the key vector.
+
+#### Step 2: Choose the Attention Type
+There are two main types of self-attention: scaled dot-product attention and multi-head attention. Scaled dot-product attention is a basic form of self-attention, while multi-head attention allows the model to jointly attend to information from different representation subspaces.
+
+#### Step 3: Implement the Self-Attention Layer
+You can implement the self-attention layer using popular deep learning frameworks such as PyTorch or TensorFlow. The self-attention layer takes in the input sequence and outputs a weighted sum of the input elements.
+
+#### Step 4: Integrate the Self-Attention Layer into the Model
+Once you have implemented the self-attention layer, you can integrate it into your deep learning model. This typically involves adding the self-attention layer to the model architecture and adjusting the model's parameters accordingly.
+
+#### Step 5: Train the Model
+After integrating the self-attention layer, you need to train the model using a suitable optimizer and loss function. The self-attention mechanism can be trained end-to-end with the rest of the model.
+
+#### Example Code
+Here's an example code snippet in PyTorch that demonstrates how to implement a basic self-attention layer:
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SelfAttention(nn.Module):
+    def __init__(self, embed_dim, num_heads):
+        super(SelfAttention, self).__init__()
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.query_linear = nn.Linear(embed_dim, embed_dim)
+        self.key_linear = nn.Linear(embed_dim, embed_dim)
+        self.value_linear = nn.Linear(embed_dim, embed_dim)
+        self.dropout = nn.Dropout(0.1)
+
+    def forward(self, x):
+        # Calculate Q, K, V
+        Q = self.query_linear(x)
+        K = self.key_linear(x)
+        V = self.value_linear(x)
+
+        # Calculate attention weights
+        attention_weights = torch.matmul(Q, K.T) / math.sqrt(self.embed_dim)
+        attention_weights = F.softmax(attention_weights, dim=-1)
+
+        # Calculate output
+        output = torch.matmul(attention_weights, V)
+        output = self.dropout(output)
+        return output
+```
+Note that this is a simplified example, and you may need to modify the code to suit your specific use case.
+
+### Advantages and Limitations of Self Attention
+The self-attention mechanism has several advantages that make it a powerful tool in deep learning models. Some of the key benefits include:
+* **Parallelization**: Self-attention allows for parallelization of sequential data, making it much faster than traditional recurrent neural networks (RNNs) for long sequences.
+* **Flexibility**: Self-attention can handle variable-length input sequences and can be used for both short-term and long-term dependencies.
+* **Interpretability**: The attention weights provide a way to visualize and understand which parts of the input sequence are most relevant for a particular task.
+
+However, self-attention also has some limitations:
+* **Computational Cost**: Self-attention has a high computational cost, especially for long sequences, due to the need to compute attention weights for every pair of elements.
+* **Memory Requirements**: Self-attention requires a significant amount of memory to store the attention weights and the input sequence.
+* **Difficulty in Handling Local Dependencies**: Self-attention can struggle to capture local dependencies, such as those found in images or text with strong spatial relationships.
+
+Despite these limitations, self-attention has the potential for future directions, including:
+* **Improving Efficiency**: Researchers are exploring ways to improve the efficiency of self-attention, such as using sparse attention or hierarchical attention.
+* **Combining with Other Mechanisms**: Self-attention can be combined with other mechanisms, such as convolutional neural networks (CNNs) or RNNs, to create more powerful models.
+* **Applying to New Domains**: Self-attention can be applied to new domains, such as computer vision or speech recognition, to improve performance and efficiency.

notebooks/understanding_self_attention_in_deep_learning.md

@@ -0,0 +1,105 @@
+# Understanding Self Attention in Deep Learning
+
+## Introduction to Self Attention
+Self attention is a fundamental concept in deep learning, enabling models to weigh the importance of different input elements relative to each other. It plays a crucial role in deep learning models, particularly in natural language processing and computer vision tasks, by allowing the model to focus on specific parts of the input data.
+
+The traditional attention mechanisms have a limitation - they rely on a fixed-length context, which can be restrictive for sequences with varying lengths. This fixed-length context can lead to information loss or inefficient processing, especially when dealing with long sequences.
+
+To address this, self attention mechanisms are used, which can be implemented using the following minimal code snippet:
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SelfAttention(nn.Module):
+    def __init__(self, embed_dim):
+        super(SelfAttention, self).__init__()
+        self.query_linear = nn.Linear(embed_dim, embed_dim)
+        self.key_linear = nn.Linear(embed_dim, embed_dim)
+        self.value_linear = nn.Linear(embed_dim, embed_dim)
+
+    def forward(self, x):
+        query = self.query_linear(x)
+        key = self.key_linear(x)
+        value = self.value_linear(x)
+        attention_scores = torch.matmul(query, key.T) / math.sqrt(key.size(-1))
+        attention_weights = F.softmax(attention_scores, dim=-1)
+        output = torch.matmul(attention_weights, value)
+        return output
+```
+This code snippet demonstrates a basic self attention implementation, highlighting its importance in deep learning models.
+
+## Implementing Self Attention
+To implement self attention, it's essential to understand the underlying mathematical formulation. The self attention mechanism is based on the concept of attention, which allows the model to focus on specific parts of the input data.
+
+* The mathematical formulation of self attention involves computing the attention weights based on the query, key, and value vectors. This is typically done using the following equation: `Attention(Q, K, V) = softmax(Q * K^T / sqrt(d)) * V`, where `Q`, `K`, and `V` are the query, key, and value vectors, respectively, and `d` is the dimensionality of the input data.
+
+The query-key-value attention mechanism is a core component of self attention. In this mechanism, the query vector represents the context in which the attention is being applied, the key vector represents the input data, and the value vector represents the importance of each input element.
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SelfAttention(nn.Module):
+    def __init__(self, embed_dim):
+        super(SelfAttention, self).__init__()
+        self.query_linear = nn.Linear(embed_dim, embed_dim)
+        self.key_linear = nn.Linear(embed_dim, embed_dim)
+        self.value_linear = nn.Linear(embed_dim, embed_dim)
+
+    def forward(self, x):
+        Q = self.query_linear(x)
+        K = self.key_linear(x)
+        V = self.value_linear(x)
+        attention_weights = F.softmax(torch.matmul(Q, K.T) / math.sqrt(x.size(-1)), dim=-1)
+        return torch.matmul(attention_weights, V)
+```
+This code example demonstrates how to implement self attention in PyTorch, a popular deep learning framework. By using this implementation, developers can easily integrate self attention into their own models.
+
+## Applications of Self Attention
+Self attention has numerous applications in various fields. 
+In natural language processing tasks, self attention is used to weigh the importance of different words in a sentence, allowing models to capture long-range dependencies and context.
+
+* Example in computer vision: self attention can be applied to image classification models to focus on specific regions of the image, as shown in this PyTorch code snippet:
+```python
+import torch
+import torch.nn as nn
+
+class SelfAttention(nn.Module):
+    def __init__(self, embed_dim):
+        super(SelfAttention, self).__init__()
+        self.query_linear = nn.Linear(embed_dim, embed_dim)
+        self.key_linear = nn.Linear(embed_dim, embed_dim)
+        self.value_linear = nn.Linear(embed_dim, embed_dim)
+
+    def forward(self, x):
+        query = self.query_linear(x)
+        key = self.key_linear(x)
+        value = self.value_linear(x)
+        attention_weights = torch.matmul(query, key.T) / math.sqrt(x.size(-1))
+        output = torch.matmul(attention_weights, value)
+        return output
+```
+Self attention can also be used in recommender systems to model user-item interactions, allowing for more accurate personalized recommendations by considering the relationships between different items.
+
+## Common Mistakes in Self Attention
+When working with self attention models, several common pitfalls can hinder performance and lead to suboptimal results. 
+
+* Overfitting is a significant problem in self attention models, where the model becomes too specialized to the training data and fails to generalize well to new, unseen data. This can be mitigated by using techniques such as dropout and early stopping, which help to prevent the model from becoming too complex.
+
+Proper initialization and regularization are also crucial when using self attention. Initialization with random weights can lead to slow convergence or getting stuck in local minima, while regularization techniques like L1 and L2 regularization can help to prevent overfitting by adding a penalty term to the loss function.
+
+To debug self attention models, follow these steps:
+* Check the input data for any inconsistencies or missing values
+* Verify that the model is correctly implemented, with attention weights being properly computed and applied
+* Monitor the model's performance on a validation set during training, and adjust hyperparameters as needed to prevent overfitting. 
+By being aware of these common mistakes and taking steps to avoid them, developers can build more effective and reliable self attention models.
+
+## Best Practices for Self Attention
+To ensure effective use of self attention in your projects, follow this checklist for production readiness:
+* Validate input data quality
+* Test model performance on diverse datasets
+* Monitor training time and memory usage
+Monitoring performance metrics, such as accuracy and loss, is crucial for identifying potential issues. 
+For further learning and improvement, refer to the Transformer library documentation and research papers on self attention mechanisms.

pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "bloggig-agent"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi>=0.135.1",
+    "google-genai>=1.64.0",
+    "huggingface-hub>=1.4.1",
+    "langchain>=1.2.10",
+    "langchain-aws>=1.2.5",
+    "langchain-community>=0.4.1",
+    "langchain-core>=1.2.13",
+    "langchain-groq>=1.1.2",
+    "langchain-tavily>=0.2.17",
+    "langgraph>=1.0.8",
+    "pillow>=12.1.1",
+    "pydantic>=2.12.5",
+    "pytest>=9.0.2",
+    "streamlit>=1.54.0",
+    "python-dotenv>=1.0.1",
+    "from-root>=1.1.0",
+    "uvicorn>=0.41.0",
+]

results/Attention is All You Need Paper Explained.md

@@ -0,0 +1,53 @@
+# Attention is All You Need Paper Explained
+## Introduction to Attention is All You Need
+The concept of attention in deep learning refers to the ability of a model to focus on specific parts of the input data that are relevant for the task at hand. 
+* Introduce the concept of attention in deep learning: Attention allows models to selectively concentrate on certain inputs or features, improving performance and efficiency.
+* Explain the limitations of traditional sequence-to-sequence models: Traditional sequence-to-sequence models rely on recurrent neural networks (RNNs) or long short-term memory (LSTM) networks, which can be limited by their sequential processing and fixed-length context.
+* Highlight the key contributions of the Attention is All You Need paper: The Attention is All You Need paper introduced a novel architecture that relies entirely on self-attention mechanisms, eliminating the need for RNNs and LSTMs, and achieving state-of-the-art results in machine translation tasks.
+![attention mechanism](../images/attention_mechanism.png)
+## The Transformer Model Architecture
+The Transformer model, introduced in the "Attention is All You Need" paper, revolutionized the field of natural language processing. At its core, the Transformer model consists of an encoder-decoder structure. 
+* The encoder takes in a sequence of tokens, such as words or characters, and generates a continuous representation of the input sequence.
+* The decoder then uses this representation to generate the output sequence, one token at a time.
+
+Self-attention mechanisms play a crucial role in the Transformer model, allowing it to weigh the importance of different tokens in the input sequence relative to each other. This is particularly useful for tasks such as machine translation, where the context of a word can greatly affect its translation. 
+
+The Transformer model also relies on positional encoding to preserve the order of the input sequence. Since the self-attention mechanism is permutation-invariant, the model would not be able to distinguish between different token orders without some form of positional information. 
+Positional encoding adds a fixed vector to each token's representation, based on its position in the sequence, allowing the model to capture sequential relationships between tokens. 
+This combination of self-attention and positional encoding enables the Transformer model to effectively process sequential data, making it a powerful tool for a wide range of NLP tasks.
+![transformer architecture](../images/transformer_architecture.png)
+## Applying the Transformer Model to Real-World Examples
+The Transformer model, introduced in the "Attention is All You Need" paper, has been widely adopted in various NLP tasks. To apply this model to real-world examples, it's essential to understand its implementation and applications.
+* A minimal code sketch of a Transformer model implementation can be represented as follows:
+```python
+import torch
+import torch.nn as nn
+import torch.optim as optim
+
+class TransformerModel(nn.Module):
+    def __init__(self):
+        super(TransformerModel, self).__init__()
+        self.encoder = nn.TransformerEncoderLayer(d_model=512, nhead=8)
+        self.decoder = nn.TransformerDecoderLayer(d_model=512, nhead=8)
+
+    def forward(self, src, tgt):
+        encoder_output = self.encoder(src)
+        decoder_output = self.decoder(tgt, encoder_output)
+        return decoder_output
+```
+* The Transformer model has been highly effective in machine translation tasks, allowing for parallelization of the decoding process and improving overall translation quality.
+* The Transformer model can also be applied to other NLP tasks, such as text classification, sentiment analysis, and question answering, by modifying the model architecture and training objectives to suit the specific task requirements.
+![transformer application](../images/transformer_application.png)
+## Common Mistakes and Challenges
+When implementing the Transformer model, several common pitfalls can hinder its performance. 
+* Proper hyperparameter tuning is crucial, as it directly affects the model's ability to learn and generalize.
+* Training large Transformer models can be challenging due to their complexity and computational requirements, often leading to issues like overfitting or slow training times.
+* Careful evaluation metrics are necessary to accurately assess the model's performance, as misleading metrics can lead to suboptimal results or incorrect conclusions about the model's effectiveness. 
+By being aware of these potential issues, developers can take steps to mitigate them and ensure successful implementation of the Transformer model.
+![common mistakes](../images/common_mistakes.png)
+## Conclusion
+The Attention is All You Need paper made significant contributions to the field of NLP, introducing a novel architecture that relies entirely on self-attention mechanisms. 
+* The main contributions of the paper include the proposal of a transformer model that replaces traditional recurrent neural network (RNN) and convolutional neural network (CNN) architectures.
+* The paper's impact on NLP has been substantial, enabling state-of-the-art results in various tasks such as machine translation and text generation.
+* Future directions for research and application include exploring the use of attention mechanisms in other areas of NLP, such as question answering and text summarization, and applying the transformer model to other domains like computer vision.
+![conclusion](../images/conclusion.png)

src/components/image_generation.py

@@ -0,0 +1,16 @@
+import os
+from huggingface_hub import InferenceClient
+
+class ImageGeneration:
+    def __init__(self):
+        self.client = InferenceClient(
+        provider="nscale",
+        api_key=os.environ["HF_TOKEN"],
+    )
+        
+    async def generateImage(self,prompt:str):
+        image = self.client.text_to_image(
+            prompt,
+            model="stabilityai/stable-diffusion-xl-base-1.0",
+        )
+        return image

src/components/taivily_search.py

@@ -0,0 +1,35 @@
+import logging
+import sys
+from typing import List
+from langchain_community.tools.tavily_search import TavilySearchResults
+from src.exception import MyException
+from src.utils.asyncHandler import asyncHandler
+
+
+class Taivily_search:
+    def __init__(self):
+        pass
+
+    @asyncHandler
+    async def _tavily_search(self, query: str, max_results: int = 5) -> List[dict]:
+        logging.info(f"Using Tavily to search for: {query}")
+        try:
+            tool = TavilySearchResults(max_results=max_results)
+            results = await tool.ainvoke({"query": query})
+
+            normalized: List[dict] = []
+            for r in results or []:
+                normalized.append(
+                    {
+                        "title": r.get("title") or "",
+                        "url": r.get("url") or "",
+                        "snippet": r.get("content") or r.get("snippet") or "",
+                        "published_at": r.get("published_date") or r.get("published_at"),
+                        "source": r.get("source"),
+                    }
+                )
+            logging.debug(f"Tavily search returned {len(normalized)} results")
+            return normalized
+        except Exception as e:
+            logging.error(f"Error in Tavily_search: {str(e)}")
+            raise MyException(e, sys)

src/constants/__init__.py

@@ -0,0 +1,2 @@
+import os
+FOLDER_PATH_TO_SAVE_MD="results"

src/exception/__init__.py

@@ -0,0 +1,40 @@
+import sys
+import logging
+
+def error_message_detail(error: Exception, error_detail: sys) -> str:
+   
+    _, _, exc_tb = error_detail.exc_info()
+
+    if exc_tb is not None:
+        # Get the file name where the exception occurred
+        file_name = exc_tb.tb_frame.f_code.co_filename
+        line_number = exc_tb.tb_lineno
+    else:
+        # Fallback to current frame info if no traceback (e.g. manual raise)
+        import inspect
+        frame = inspect.currentframe().f_back.f_back # Go back to where MyException was called
+        file_name = frame.f_code.co_filename
+        line_number = frame.f_lineno
+
+    # Create a formatted error message string with file name, line number, and the actual error
+    error_message = f"Error occurred in python script: [{file_name}] at line number [{line_number}]: {str(error)}"
+    
+    # Log the error for better tracking
+    logging.error(error_message)
+    
+    return error_message
+
+
+class MyException(Exception):
+    def __init__(self, error_message: str, error_detail: sys):
+        # Call the base class constructor with the error message
+        super().__init__(error_message)
+
+        # Format the detailed error message using the error_message_detail function
+        self.error_message = error_message_detail(error_message, error_detail)
+
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the error message.
+        """
+        return self.error_message

src/graph/Compile_graph.py

@@ -0,0 +1,74 @@
+import logging
+import asyncio
+from dotenv import load_dotenv
+from langgraph.graph import StateGraph,START,END
+from src.models.State_model import State
+from src.graph.nodes.router_node import router_node,route_next
+from src.graph.nodes.reducer_node import reducer_node
+from src.graph.nodes.search_node import research_node
+from src.graph.nodes.orchaster_node import orchestrator_node
+from src.graph.nodes.worker_node import worker_node
+from src.graph.nodes.fanout_node import fanout
+load_dotenv()
+
+g = StateGraph(State)
+g.add_node("router", router_node)
+g.add_node("research", research_node)
+g.add_node("orchestrator", orchestrator_node)
+g.add_node("worker", worker_node)
+g.add_node("reducer", reducer_node)
+
+g.add_edge(START, "router")
+g.add_conditional_edges("router", route_next, {"research": "research", "orchestrator": "orchestrator"})
+g.add_edge("research", "orchestrator")
+
+g.add_conditional_edges("orchestrator", fanout, ["worker"])
+g.add_edge("worker", "reducer")
+g.add_edge("reducer", END)
+
+app = g.compile()
+
+
+png_data = app.get_graph().draw_mermaid_png()
+with open("graph.png", "wb") as f:
+    f.write(png_data)
+async def run(topic: str):
+    logging.info(f"Starting blog generation for topic: {topic}")
+    try:
+        # out = await app.ainvoke(
+        #     {
+        #         "topic": topic,
+        #         "mode": "",
+        #         "needs_research": False,
+        #         "queries": [],
+        #         "evidence": [],
+        #         "plan": None,
+        #         "sections": [],
+        #         "final": "",
+        #     }
+        # )
+        async for step in app.astream(
+            {
+                "topic": topic,
+                "mode": "",
+                "needs_research": False,
+                "queries": [],
+                "evidence": [],
+                "plan": None,
+                "sections": [],
+                "final": "",
+            },
+            stream_mode="values"   # important
+        ):
+            # print("Current Step:", step)
+            yield step
+        logging.info("Blog generation completed successfully")
+        return
+    except Exception as e:
+        logging.error(f"Error during graph execution: {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    from src.logger import *
+    out=asyncio.run(run("State of Multimodal LLMs in 2026"))
+    print(out)

src/graph/graphs/reducer_subgraph.py

@@ -0,0 +1,22 @@
+import logging
+from langgraph.graph import StateGraph,START,END
+from src.models.ImageSpec_model import State
+from src.graph.nodes.reducer_sub_node import reducer_sub_image,reducer_sub_llm,merge_images_and_md
+app=StateGraph(State)
+
+
+app.add_node("reducer_sub_llm",reducer_sub_llm)
+app.add_node("reducer_sub_image",reducer_sub_image)
+app.add_node("merge_images_and_md",merge_images_and_md)
+
+app.add_edge(START,"reducer_sub_llm")
+app.add_edge("reducer_sub_llm","reducer_sub_image")
+app.add_edge("reducer_sub_image","merge_images_and_md")
+app.add_edge("merge_images_and_md",END)
+
+
+
+
+app=app.compile()
+logging.info("Reducer subgraph compiled successfully")
+

src/graph/nodes/fanout_node.py

@@ -0,0 +1,23 @@
+import logging
+from src.models.State_model import State
+from langgraph.types import Send
+
+
+def fanout(state: State):
+    logging.info("Entering fanout")
+    tasks = state["plan"].tasks
+    logging.debug(f"Fanning out {len(tasks)} tasks")
+    
+    return [
+        Send(
+            "worker",
+            {
+                "task": task.model_dump(),
+                "topic": state["topic"],
+                "mode": state["mode"],
+                "plan": state["plan"].model_dump(),
+                "evidence": [e.model_dump() for e in state.get("evidence", [])],
+            },
+        )
+        for task in tasks
+    ]

src/graph/nodes/orchaster_node.py

@@ -0,0 +1,40 @@
+import logging
+import sys
+from src.models.State_model import State
+from src.llm import llm
+from src.exception import MyException
+from src.models.Plan_model import Plan
+from src.prompts import ORCH_SYSTEM
+from langchain_core.messages import SystemMessage, HumanMessage
+from src.utils.asyncHandler import asyncHandler
+
+
+@asyncHandler
+async def orchestrator_node(state: State) -> dict:
+    logging.info("Entering orchestrator_node")
+    try:
+        planner = llm.with_structured_output(Plan)
+
+        evidence = state.get("evidence", [])
+        mode = state.get("mode", "closed_book")
+        logging.debug(f"Mode: {mode}, Evidence count: {len(evidence)}")
+
+        plan = await planner.ainvoke(
+            [
+                SystemMessage(content=ORCH_SYSTEM),
+                HumanMessage(
+                    content=(
+                        f"Topic: {state['topic']}\n"
+                        f"Mode: {mode}\n\n"
+                        f"Evidence (ONLY use for fresh claims; may be empty):\n"
+                        f"{[e.model_dump() for e in evidence][:16]}"
+                    )
+                ),
+            ]
+        )
+
+        logging.info(f"Orchestrator plan created: {plan.blog_title} with {len(plan.tasks)} tasks.")
+        return {"plan": plan}
+    except Exception as e:
+        logging.error(f"Error in orchestrator_node: {str(e)}")
+        raise MyException(e, sys)

src/graph/nodes/reducer_node.py

@@ -0,0 +1,36 @@
+import logging
+import sys
+from pathlib import Path
+from src.models.State_model import State
+from src.exception import MyException
+from src.utils.asyncHandler import asyncHandler
+from src.constants import FOLDER_PATH_TO_SAVE_MD
+import os
+from src.graph.graphs.reducer_subgraph import app
+@asyncHandler
+async def reducer_node(state: State) -> dict:
+    logging.info("Entering reducer_node")
+    try:
+        plan = state["plan"]
+
+        ordered_sections = [md for _, md in sorted(state["sections"], key=lambda x: x[0])]
+        body = "\n\n".join(ordered_sections).strip()
+        final_md = f"# {plan.blog_title}\n\n{body}\n"
+
+        filename = f"{plan.blog_title}.md"
+        logging.debug(f"Writing final blog to {filename}")
+
+        logging.info("Starting image generation and merging via subgraph")
+        red_f_ob=await app.ainvoke({"prompt_markdown":final_md})
+        final_md=red_f_ob["final_md"]
+        
+        logging.debug(f"Final MD size after merging: {len(final_md)} characters")
+        os.makedirs(FOLDER_PATH_TO_SAVE_MD,exist_ok=True)
+        file_path=os.path.join(FOLDER_PATH_TO_SAVE_MD,filename)
+        Path(file_path).write_text(final_md, encoding="utf-8")
+
+        logging.info(f"Reducer node completed successfully, blog saved to {file_path}")
+        return {"final": final_md}
+    except Exception as e:
+        logging.error(f"Error in reducer_node: {str(e)}")
+        raise MyException(e, sys)

src/graph/nodes/reducer_sub_node.py

@@ -0,0 +1,69 @@
+import logging
+from src.models.ImageSpec_model import State,GlobalImagePlan
+from src.utils.asyncHandler import asyncHandler
+from langchain.messages import SystemMessage,HumanMessage
+from src.prompts import IMAGE_PLACEHOLDER_GENERATION
+from src.llm import llm
+from src.exception import MyException
+import sys
+import os
+from src.components.image_generation import ImageGeneration
+@asyncHandler
+async def reducer_sub_llm(state:State)->State:
+    logging.info("Calling LLM for image placeholder planning")
+    output=await llm.with_structured_output(GlobalImagePlan)\
+    .ainvoke(
+        [
+        SystemMessage(content=IMAGE_PLACEHOLDER_GENERATION),
+        HumanMessage(content=state['prompt_markdown'])
+        ]
+    )
+    if not output:
+        logging.error("LLM failed to return a valid image placeholder plan (output is None)")
+        raise MyException("Failed to generate image placeholder plan from LLM", sys)
+    
+    state['output']=output
+    logging.info("Successfully generated image placeholder plan")
+    return state
+
+@asyncHandler
+async def reducer_sub_image(state:State)->State:
+    output=state['output']
+    image_generator=ImageGeneration()
+    if not output:
+        raise MyException("output from reducer_sub not found",sys)
+    
+    os.makedirs("images",exist_ok=True)
+
+    logging.info(f"Starting image generation for {len(output.images)} images")
+    for image_con in output.images:
+        logging.debug(f"Generating image: {image_con.filename} with prompt: {image_con.prompt[:50]}...")
+        image=await image_generator.generateImage(prompt=image_con.prompt)
+        image.save(image_con.filename)
+    logging.info("All images generated successfully")
+    return state
+
+@asyncHandler
+async def merge_images_and_md(state: State) -> State:
+    output = state["output"]
+    md = output.md_with_placeholders
+    
+    logging.info(f"Merging {len(output.images)} images into Markdown")
+    for im in output.images:
+        alt_text = (
+            im.filename.split("/")[-1]
+            .replace(".png", "")
+            .replace("_", " ")
+        )
+
+        md_image_tag = f"![{alt_text}](../{im.filename})"
+        md = md.replace(im.placeholder, md_image_tag)
+
+    state["final_md"] = md
+    logging.info("Markdown merging completed")
+    return state    
+
+
+
+
+

src/graph/nodes/router_node.py

@@ -0,0 +1,103 @@
+import logging
+import sys
+import json
+import re
+from src.models.RouterDecision_model import RouterDecision
+from langchain_core.messages import SystemMessage, HumanMessage
+from src.models.State_model import State
+from src.llm import llm
+from src.prompts import ROUTER_SYSTEM
+from src.exception import MyException
+from src.utils.asyncHandler import asyncHandler
+
+
+@asyncHandler
+async def router_node(state: State):
+    logging.info("Entering router_node")
+    topic = state['topic']
+    logging.debug(f"Topic: {topic}")
+    
+    try:
+        try:
+            runnable = llm.with_structured_output(RouterDecision)
+            decision = await runnable.ainvoke(
+                [
+                    SystemMessage(content=ROUTER_SYSTEM),
+                    HumanMessage(content=f"Topic: {topic}")
+                ]
+            )
+            if decision:
+                logging.info(f"Router decision (structured): needs_research={decision.needs_research}, mode={decision.mode}")
+                return {
+                    "needs_research": decision.needs_research,
+                    "mode": decision.mode,
+                    "queries": decision.queries,
+                }
+        except Exception as e:
+            logging.warning(f"Structured output failed: {str(e)}. Attempting manual parse.")
+
+        raw_response = await llm.ainvoke(
+            [
+                SystemMessage(content=ROUTER_SYSTEM + "\n\nCRITICAL: You MUST return a valid JSON object. Do not include any text before or after the JSON."),
+                HumanMessage(content=f"Topic: {topic}")
+            ]
+        )
+        content = raw_response.content
+        logging.debug(f"Raw LLM content for fallback: {content}")
+
+        json_str = ""
+        markdown_match = re.search(r'```json\s*(.*?)\s*```', content, re.DOTALL)
+        if markdown_match:
+            json_str = markdown_match.group(1)
+        else:
+            start = content.find('{')
+            end = content.rfind('}')
+            if start != -1 and end != -1:
+                json_str = content[start:end+1]
+        
+        if json_str:
+            try:
+                data = json.loads(json_str)
+            except json.JSONDecodeError:
+                # Progressive truncation fallback
+                success = False
+                temp_str = json_str
+                while '}' in temp_str:
+                    try:
+                        data = json.loads(temp_str)
+                        success = True
+                        break
+                    except json.JSONDecodeError:
+                        last_brace = temp_str.rfind('}')
+                        if last_brace == -1: break
+                        temp_str = temp_str[:last_brace]
+                
+                if not success:
+                    raise ValueError("Failed to parse JSON even after structural truncation")
+
+            needs_res = str(data.get("needs_research", "")).lower() in ["true", "1", "yes"]
+            
+            decision = RouterDecision(
+                needs_research=needs_res,
+                mode=data.get("mode", "open_book"),
+                queries=data.get("queries", [])
+            )
+            logging.info(f"Router decision (manual): needs_research={decision.needs_research}, mode={decision.mode}")
+            return {
+                "needs_research": decision.needs_research,
+                "mode": decision.mode,
+                "queries": decision.queries,
+            }
+
+        logging.error("Failed to extract JSON from LLM response")
+        raise ValueError("LLM failed to return a valid RouterDecision. Please check prompts or model output.")
+
+    except Exception as e:
+        logging.error(f"Error in router_node: {str(e)}")
+        raise
+
+def route_next(state: State) -> str:
+    # Use .get() to avoid KeyError if node failed
+    needs_research = state.get("needs_research", False)
+    logging.info(f"Routing next based on research need: {needs_research}")
+    return "research" if needs_research else "orchestrator"