Upload folder using huggingface_hub

README.md

@@ -1,12 +1,316 @@
 ---
 title: ScholarShare
-emoji: 🔥
-colorFrom: gray
-colorTo: yellow
+emoji: 📚
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.33.0
+sdk_version: 5.32.0
 app_file: app.py
 pinned: false
+license: mit
+short_description: AI-powered academic paper analysis and content generation
+suggested_hardware: t4-small
+suggested_storage: small
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎓 ScholarShare - AI-Powered Research Dissemination Platform
+
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/charliermarsh/ruff)
+
+**ScholarShare** is an innovative platform designed to bridge the gap between complex academic research and broader public understanding. It leverages cutting-edge AI to transform dense research papers into accessible and engaging content formats, including blog posts, social media updates, and conference posters. Our goal is to empower researchers to maximize the impact of their work and foster a more informed society. 🚀
+
+## ✨ Features
+
+*   📄 **Multi-Format Paper Ingestion:** Upload PDFs, provide URLs (e.g., arXiv links), or paste raw text.
+*   🧠 **In-Depth AI Analysis:** Extracts key information: title, authors, abstract, methodology, findings, results, conclusion, complexity, and technical terms.
+*   📝 **Automated Blog Generation:** Creates beginner-friendly blog posts from research papers, complete with title, content, tags, and estimated reading time.
+*   📱 **Social Media Content Creation:** Generates platform-specific content (LinkedIn, Twitter, Facebook, Instagram) including text posts and relevant images.
+*   🎨 **Academic Poster Generation:** Produces LaTeX-based conference posters with customizable templates (IEEE, ACM, Nature) and orientations (landscape, portrait).
+*   📊 **Presentation Generation:** Creates Beamer LaTeX presentations with customizable templates (academic, corporate, minimal) and adjustable slide counts (8-20 slides).
+*   🚀 **Direct Publishing (DEV.to):** Seamlessly publish generated blog content to DEV.to as drafts or immediately.
+*   📥 **Downloadable Outputs:** All generated content (analysis summaries, blog posts, LaTeX code, PDFs) can be easily downloaded.
+*   🌐 **User-Friendly Interface:** Built with Gradio for an intuitive and interactive experience.
+
+## 🛠️ Tech Stack
+
+*   🐍 **Backend:** Python
+*   🤖 **AI/ML:** Various LLM services (via `app.services.llm_service`)
+*   🖼️ **Web Framework/UI:** Gradio (`gradio`, `gradio-pdf`)
+*   📄 **PDF Processing:** `pdf_service` (details depend on implementation, e.g., PyMuPDF, pdfminer)
+*   📜 **LaTeX Compilation:** (Assumed, for poster generation, e.g., `pdflatex` via `poster_service`)
+*   🔗 **API Integration:** DEV.to API (via `devto_service`)
+*   📦 **Packaging:** Poetry (implied by `pyproject.toml` and `uv.lock`)
+
+## 🌊 Architecture & Workflow
+
+ScholarShare processes research papers through a series of AI agents and services to generate various content formats.
+
+```mermaid
+graph TD
+    %% Nodes
+    A[User Input: PDF/URL/Text] --> B{Paper Processing Service}
+    B -- Extracted Content --> C[Paper Analyzer Agent]
+    C -- Analysis Data --> D{Core Analysis Object}
+
+    D --> E[Blog Generator Agent]
+    E -- Blog Data --> F[Blog Output: Markdown / DEV.to]
+
+    D --> G[TLDR / Social Media Agent]
+    G -- Social Media Data --> H[Social Media Posts & Images]
+
+    D --> I[Poster Generator Agent]
+    I -- Poster Data & Template --> J[Poster Output: LaTeX / PDF]
+
+    subgraph "User Interface (Gradio)"
+        direction LR
+        K[Upload/Input Section] --> A
+        F --> L[Blog Display & Publish]
+        H --> M[Social Media Display]
+        J --> N[Poster Display & Download]
+    end
+
+    %% Node Styles: Better readability on dark background
+    style A fill:#ffffff,stroke:#000,stroke-width:2px,color:#000
+    style B fill:#d0e1ff,stroke:#000,stroke-width:2px,color:#000
+    style C fill:#d0e1ff,stroke:#000,stroke-width:2px,color:#000
+    style D fill:#ffff99,stroke:#000,stroke-width:2px,color:#000
+    style E fill:#e1f5c4,stroke:#000,stroke-width:2px,color:#000
+    style G fill:#e1f5c4,stroke:#000,stroke-width:2px,color:#000
+    style I fill:#e1f5c4,stroke:#000,stroke-width:2px,color:#000
+    style F fill:#cceeff,stroke:#000,stroke-width:2px,color:#000
+    style H fill:#cceeff,stroke:#000,stroke-width:2px,color:#000
+    style J fill:#cceeff,stroke:#000,stroke-width:2px,color:#000
+    style K fill:#dddddd,stroke:#000,stroke-width:2px,color:#000
+    style L fill:#eeeeee,stroke:#000,stroke-width:2px,color:#000
+    style M fill:#eeeeee,stroke:#000,stroke-width:2px,color:#000
+    style N fill:#eeeeee,stroke:#000,stroke-width:2px,color:#000
+
+```
+
+## 📁 Project Structure
+
+A high-level overview of the ScholarShare project directory.
+
+```mermaid
+graph TD
+    R[ScholarShare Root]
+    R --> F1[scholarshare/]
+    R --> F2[1706.03762v7.pdf]
+    R --> F3[README.md]
+    R --> F4[requirements.txt]
+    R --> F5[pyproject.toml]
+    R --> F6[Dockerfile]
+    R --> F7[docker-compose.yml]
+
+    F1 --> S1[main.py Gradio App]
+    F1 --> S2[app/]
+    F1 --> S3[data/]
+    F1 --> S4[outputs/]
+    F1 --> S5[parsed_pdf_content.txt]
+
+    S2 --> A1[agents/]
+    S2 --> A2[config/]
+    S2 --> A3[database/]
+    S2 --> A4[models/]
+    S2 --> A5[services/]
+    S2 --> A6[templates/]
+    S2 --> A7[utils/]
+
+    A1 --> AG1[paper_analyzer.py]
+    A1 --> AG2[blog_generator.py]
+    A1 --> AG3[tldr_generator.py]
+    A1 --> AG4[poster_generator.py]
+
+    A5 --> SV1[pdf_service.py]
+    A5 --> SV2[llm_service.py]
+    A5 --> SV3[devto_service.py]
+    A5 --> SV4[poster_service.py]
+
+    %% Light styles for dark mode visibility
+    style R fill:#ffffff,stroke:#000,stroke-width:2px,color:#000
+    style F1 fill:#e8f0fe,stroke:#000,stroke-width:1.5px,color:#000
+    style F2 fill:#f9f9f9,stroke:#000,stroke-width:1px,color:#000
+    style F3 fill:#f9f9f9,stroke:#000,stroke-width:1px,color:#000
+    style F4 fill:#f9f9f9,stroke:#000,stroke-width:1px,color:#000
+    style F5 fill:#f9f9f9,stroke:#000,stroke-width:1px,color:#000
+    style F6 fill:#f9f9f9,stroke:#000,stroke-width:1px,color:#000
+    style F7 fill:#f9f9f9,stroke:#000,stroke-width:1px,color:#000
+    style S1 fill:#f1f8e9,stroke:#000,stroke-width:1px,color:#000
+    style S2 fill:#fff3e0,stroke:#000,stroke-width:1px,color:#000
+    style S3 fill:#f1f8e9,stroke:#000,stroke-width:1px,color:#000
+    style S4 fill:#f1f8e9,stroke:#000,stroke-width:1px,color:#000
+    style S5 fill:#f1f8e9,stroke:#000,stroke-width:1px,color:#000
+    style A1 fill:#ffe0b2,stroke:#000,stroke-width:0.5px,color:#000
+    style A2 fill:#ffe0b2,stroke:#000,stroke-width:0.5px,color:#000
+    style A3 fill:#ffe0b2,stroke:#000,stroke-width:0.5px,color:#000
+    style A4 fill:#ffe0b2,stroke:#000,stroke-width:0.5px,color:#000
+    style A5 fill:#ffe0b2,stroke:#000,stroke-width:0.5px,color:#000
+    style A6 fill:#ffe0b2,stroke:#000,stroke-width:0.5px,color:#000
+    style A7 fill:#ffe0b2,stroke:#000,stroke-width:0.5px,color:#000
+    style AG1 fill:#fff,stroke:#000,stroke-width:0.5px,color:#000
+    style AG2 fill:#fff,stroke:#000,stroke-width:0.5px,color:#000
+    style AG3 fill:#fff,stroke:#000,stroke-width:0.5px,color:#000
+    style AG4 fill:#fff,stroke:#000,stroke-width:0.5px,color:#000
+    style SV1 fill:#fff,stroke:#000,stroke-width:0.5px,color:#000
+    style SV2 fill:#fff,stroke:#000,stroke-width:0.5px,color:#000
+    style SV3 fill:#fff,stroke:#000,stroke-width:0.5px,color:#000
+    style SV4 fill:#fff,stroke:#000,stroke-width:0.5px,color:#000
+
+```
+
+## 🚀 Getting Started
+
+### 📋 Prerequisites
+
+*   Python 3.10+
+*   Poetry (for dependency management - recommended) or pip
+*   Access to a LaTeX distribution (e.g., TeX Live, MiKTeX) for poster generation.
+*   (Optional) Docker 🐳
+
+### ⚙️ Installation
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/your-username/ScholarShare.git # Replace with actual repo URL
+    cd ScholarShare
+    ```
+
+2.  **Set up environment variables:**
+    Create a `.env` file in the `scholarshare/app/config/` directory or directly in `scholarshare/` if `settings.py` is configured to look there.
+    Populate it with necessary API keys and configurations (e.g., `OPENAI_API_KEY`, `DEVTO_API_KEY`).
+    Example `scholarshare/app/config/.env` (or `scholarshare/.env`):
+    ```env
+    OPENAI_API_KEY="your_openai_api_key"
+    DEVTO_API_KEY="your_devto_api_key"
+    # Other settings from settings.py
+    HOST="0.0.0.0"
+    PORT=7860
+    DEBUG=True
+    ```
+    *(Ensure `settings.py` loads these, e.g., using `python-dotenv`)*
+
+3.  **Install dependencies:**
+
+    *   **Using Poetry (recommended):**
+        ```bash
+        poetry install
+        ```
+
+    *   **Using pip and `requirements.txt`:**
+        ```bash
+        pip install -r requirements.txt
+        ```
+        *(Note: `requirements.txt` might need to be generated from `pyproject.toml` if not kept up-to-date: `poetry export -f requirements.txt --output requirements.txt --without-hashes`)*
+
+4.  **Ensure output directories exist:**
+    The application creates these, but you can pre-create them:
+    ```bash
+    mkdir -p scholarshare/outputs/posters
+    mkdir -p scholarshare/outputs/blogs
+    mkdir -p scholarshare/data
+    ```
+
+### ▶️ Running the Application
+
+*   **Using Poetry:**
+    ```bash
+    cd scholarshare
+    poetry run python main.py
+    ```
+
+*   **Using Python directly:**
+    ```bash
+    cd scholarshare
+    python main.py
+    ```
+
+The application will typically be available at `http://localhost:7860` or `http://0.0.0.0:7860`.
+
+### 🐳 Running with Docker (if `Dockerfile` and `docker-compose.yml` are configured)
+
+1.  **Build the Docker image:**
+    ```bash
+    docker-compose build
+    ```
+2.  **Run the container:**
+    ```bash
+    docker-compose up
+    ```
+    The application should be accessible as configured in `docker-compose.yml`.
+
+## 📖 Usage
+
+1.  **Navigate to the "Paper Input & Analysis" Tab:**
+    *   **Upload PDF:** Click "Upload PDF Paper" and select your research paper.
+    *   **Enter URL:** Paste a direct link to a PDF (e.g., an arXiv abstract page URL might work if the service can resolve it to a PDF, or a direct PDF link).
+    *   **Paste Text:** Copy and paste the raw text content of your paper.
+2.  **Analyze Paper:** Click the "🔍 Analyze Paper" button. Wait for the status to show "✅ Paper processed successfully!". The analysis summary will appear.
+3.  **Generate Blog Content:**
+    *   Go to the "📝 Blog Generation" tab.
+    *   Click "✍️ Generate Blog Content". The generated blog post will appear.
+    *   You can download it as Markdown.
+4.  **Generate Social Media Content:**
+    *   Go to the "📱 Social Media Content" tab.
+    *   Click "📱 Generate Social Content". Content for LinkedIn, Twitter, Facebook, and Instagram will be generated, along with associated images if applicable.
+5.  **Generate Poster:**
+    *   Go to the "🎨 Poster Generation" tab.
+    *   Select a "Poster Template Style" (e.g., IEEE, ACM).
+    *   Select "Poster Orientation" (landscape or portrait).
+    *   Click "🎨 Generate Poster". A PDF preview and LaTeX code will be displayed. You can download both.
+6.  **Generate Presentation:**
+    *   Go to the "📊 Presentation Generation" tab.
+    *   Select a "Presentation Template Style" (academic, corporate, minimal).
+    *   Adjust the "Number of Slides" (8-20 slides).
+    *   Click "📊 Generate Presentation". A PDF preview and Beamer LaTeX code will be displayed. You can download both.
+7.  **Publish to DEV.to:**
+    *   Go to the "🚀 Publishing" tab (ensure blog content is generated first).
+    *   Click "💾 Save as Draft" or "🚀 Publish Now". The status of the publication will be shown.
+
+## 🖼️ Screenshots / Demo
+
+*(Placeholder: Add screenshots of the Gradio interface for each tab and feature. A GIF demonstrating the workflow would be excellent here.)*
+
+**Example: Paper Input Tab**
+`[Image of Paper Input Tab]`
+
+**Example: Blog Generation Tab**
+`[Image of Blog Generation Tab]`
+
+**Example: Poster Preview**
+`[Image of Poster Preview]`
+
+## 🤝 Contributing
+
+Contributions are welcome! Whether it's bug fixes, feature enhancements, or documentation improvements, please feel free to:
+
+1.  **Fork the repository.**
+2.  **Create a new branch:** `git checkout -b feature/your-feature-name` or `bugfix/issue-number`.
+3.  **Make your changes.** Ensure your code follows the project's style guidelines (e.g., run `black .` for formatting).
+4.  **Write tests** for new features or bug fixes if applicable.
+5.  **Commit your changes:** `git commit -m "feat: Describe your feature"` or `fix: Describe your fix`.
+6.  **Push to the branch:** `git push origin feature/your-feature-name`.
+7.  **Open a Pull Request** against the `main` (or `develop`) branch.
+
+Please provide a clear description of your changes in the PR.
+
+## 📜 License
+
+This project is licensed under the **MIT License**. See the [LICENSE](LICENSE.md) file for details.
+*(Note: You'll need to create a `LICENSE.md` file with the MIT license text if it doesn't exist.)*
+
+## 📞 Contact & Support
+
+*   **Issues:** If you encounter any bugs or have feature requests, please [open an issue](https://github.com/your-username/ScholarShare/issues) on GitHub. <!-- Replace with actual repo URL -->
+*   **Maintainer:** [Your Name/Organization] - [[email protected]] <!-- Update with actual contact -->
+
+## 🙏 Acknowledgements
+
+*   The [Gradio](https://www.gradio.app/) team for the easy-to-use UI framework.
+*   Providers of the LLM services used for content generation.
+*   The open-source community for the various libraries and tools that make this project possible.
+
+---
+*This README was generated with assistance from an AI coding agent.*

app.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""
+Entry point for Hugging Face Spaces deployment.
+This file is required by HF Spaces and should be named 'app.py' in the root directory.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add the current directory to Python path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Import and run the main application
+from main import create_interface
+
+if __name__ == "__main__":
+    # Create output directories
+    Path("outputs/posters").mkdir(parents=True, exist_ok=True)
+    Path("outputs/blogs").mkdir(parents=True, exist_ok=True)
+    Path("outputs/presentations").mkdir(parents=True, exist_ok=True)
+    Path("data").mkdir(parents=True, exist_ok=True)
+    
+    # Create the Gradio interface
+    app = create_interface()
+    
+    # Launch with Hugging Face Spaces compatible settings
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,  # HF Spaces uses port 7860
+        share=False,
+        debug=False
+    )

app/agents/base_agent.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+from app.services.llm_service import llm_service
+
+
+class BaseAgent(ABC):
+    def __init__(self, name: str, model_type: str = "light"):
+        self.name = name
+        self.model_type = model_type
+        self.llm_service = llm_service
+
+    @abstractmethod
+    async def process(self, input_data: Any) -> Dict[str, Any]:
+        """Process input and return results"""
+
+    async def generate_response(self, messages: list, temperature: float = 0.7) -> str:
+        """Generate LLM response"""
+        return await self.llm_service.generate_completion(
+            messages=messages,
+            model_type=self.model_type,
+            temperature=temperature,
+        )

app/agents/blog_generator.py

@@ -0,0 +1,221 @@
+from app.agents.base_agent import BaseAgent
+from app.models.schemas import BlogContent, PaperAnalysis
+from app.services.blog_image_service import blog_image_service
+
+
+class BlogGeneratorAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("BlogGenerator", model_type="light")
+
+    async def process(self, analysis: PaperAnalysis) -> BlogContent:
+        """Generate beginner-friendly blog content from paper analysis"""
+        blog_prompt = f"""
+        You are an expert computer scientist specializes in the area of machine learning. Transform this research paper analysis into an engaging, highly technical yet beginner-friendly blog post.
+
+        Paper Analysis:
+        Title: {analysis.title}
+        Authors: {", ".join(analysis.authors)}
+        Abstract: {analysis.abstract}
+        Key Findings: {", ".join(analysis.key_findings)}
+        Methodology: {analysis.methodology}
+        Results: {analysis.results}
+        Conclusion: {analysis.conclusion}
+        Complexity Level: {analysis.complexity_level}
+
+        Create a blog post that:
+        1. Use technical language and explain complex concepts in simple terms
+        2. Uses analogies to explain technical terms
+        3. Has an engaging introduction that hooks the reader
+        4. Clearly explains the significance of the research
+        5. Includes practical implications of the findings
+        6. Is optimized for SEO with proper structure and headings
+        7. Must explain the key findings and methodology in great detail.
+        8. Use markdown formatting for code snippets, equations, and figures
+
+        Structure the blog post with:
+        - Catchy title
+        - Engaging introduction
+        - Main sections with clear headings
+        - Conclusion with key takeaways
+
+        Make it interesting for a general audience while maintaining scientific accuracy.
+        Don't include any other information except the blog post content. No additional headers or ending text in the response.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are an expert computer scientist expert in machine learning and artificial intelligence also you are expert in blog writing, who excels at making complex research accessible to everyone.",
+            },
+            {"role": "user", "content": blog_prompt},
+        ]
+
+        response = await self.generate_response(messages, temperature=0.7)
+
+        # Extract title, content, and tags
+        title = self._extract_title(response)
+        content = self._clean_content(response)
+        tags = self._extract_tags(response, analysis)
+        meta_description = self._generate_meta_description(analysis)
+        reading_time = self._calculate_reading_time(content)
+
+        # Generate and embed images into the blog content
+        try:
+            print("Generating images for blog post...")
+            images = await blog_image_service.generate_blog_images(analysis, content)
+            if images:
+                print(f"Generated {len(images)} images successfully")
+                content = await blog_image_service.embed_images_in_content(
+                    content, images
+                )
+                # Update reading time to account for images
+                reading_time = (
+                    self._calculate_reading_time(content) + 1
+                )  # Add 1 minute for images
+            else:
+                print("No images were generated")
+        except Exception as e:
+            print(f"Failed to generate images for blog: {e}")
+            # Continue without images if generation fails
+
+        # Save the blog content in a file
+        with open(f"{title}.md", "w") as f:
+            f.write(content)
+
+        return BlogContent(
+            title=title,
+            content=content,
+            tags=tags,
+            meta_description=meta_description,
+            reading_time=reading_time,
+        )
+
+    def _extract_title(self, content: str) -> str:
+        """Extract title from blog content"""
+        lines = content.split("\n")
+        for line in lines:
+            if line.strip().startswith("#") and not line.strip().startswith("##"):
+                return line.strip().replace("#", "").strip()
+        return "Research Insights: Latest Findings"
+
+    def _clean_content(self, content: str) -> str:
+        """Clean and format blog content"""
+        # Remove title from content if it's duplicated
+        lines = content.split("\n")
+        cleaned_lines = []
+        title_found = False
+
+        for line in lines:
+            if (
+                line.strip().startswith("#")
+                and not line.strip().startswith("##")
+                and not title_found
+            ):
+                title_found = True
+                continue
+            cleaned_lines.append(line)
+
+        return "\n".join(cleaned_lines).strip()
+
+    def _extract_tags(self, content: str, analysis: PaperAnalysis) -> list:
+        """Extract relevant tags for the blog post"""
+        base_tags = ["research", "science", "academic"]
+
+        # Add complexity-based tags
+        if analysis.complexity_level == "beginner":
+            base_tags.extend(["beginners", "explained"])
+        elif analysis.complexity_level == "advanced":
+            base_tags.extend(["advanced", "technical"])
+
+        # Add field-specific tags based on content
+        content_lower = content.lower()
+        field_tags = {
+            "ai": [
+                "ai",
+                "machinelearning",
+                "artificialintelligence",
+                "deeplearning",
+                "neuralnetworks",
+                "automation",
+                "computervision",
+                "nlp",
+                "generativeai",
+            ],
+            "machine learning": [
+                "machinelearning",
+                "ml",
+                "datascience",
+                "supervisedlearning",
+                "unsupervisedlearning",
+                "reinforcementlearning",
+                "featureengineering",
+                "modeloptimization",
+            ],
+            "computer science": [
+                "computerscience",
+                "programming",
+                "technology",
+                "softwareengineering",
+                "algorithms",
+                "datastructures",
+                "computationaltheory",
+                "systemsdesign",
+            ],
+            "data science": [
+                "datascience",
+                "bigdata",
+                "datamining",
+                "datavisualization",
+                "statistics",
+                "predictiveanalytics",
+                "dataengineering",
+            ],
+            "cybersecurity": [
+                "cybersecurity",
+                "infosec",
+                "ethicalhacking",
+                "cryptography",
+                "networksecurity",
+                "applicationsecurity",
+                "securityengineering",
+            ],
+            "software development": [
+                "softwaredevelopment",
+                "coding",
+                "devops",
+                "agile",
+                "testing",
+                "debugging",
+                "versioncontrol",
+                "softwarearchitecture",
+            ],
+            "cloud computing": [
+                "cloudcomputing",
+                "aws",
+                "azure",
+                "googlecloud",
+                "serverless",
+                "containers",
+                "kubernetes",
+                "cloudsecurity",
+            ],
+        }
+
+        for field, tags in field_tags.items():
+            if field in content_lower:
+                base_tags.extend(tags[:2])
+                break
+
+        return list(set(base_tags))[:10]  # Limit to 10 tags
+
+    def _generate_meta_description(self, analysis: PaperAnalysis) -> str:
+        """Generate SEO meta description"""
+        if analysis.key_findings:
+            finding = analysis.key_findings[0]
+            return f"Discover how {finding[:100]}... Latest research insights explained in simple terms."
+        return f"Explore the latest research findings from {analysis.title[:50]}... explained for everyone."
+
+    def _calculate_reading_time(self, content: str) -> int:
+        """Calculate estimated reading time in minutes"""
+        word_count = len(content.split())
+        return max(1, word_count // 200)  # Assuming 200 words per minute

app/agents/paper_analyzer.py

@@ -0,0 +1,87 @@
+import json
+import re
+
+from app.agents.base_agent import BaseAgent
+from app.models.schemas import PaperAnalysis, PaperInput
+
+
+class PaperAnalyzerAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("PaperAnalyzer", model_type="light")
+
+    async def process(self, input_data: PaperInput) -> PaperAnalysis:
+        """Analyze research paper and extract key information"""
+        analysis_prompt = f"""
+        You are an expert research paper analyzer. Analyze the following research paper content and extract key information in JSON format.
+
+        Paper Content:
+        {input_data.content}
+
+        Please provide a detailed analysis in the following JSON structure:
+        {{
+            "title": "Paper title",
+            "authors": ["Author 1", "Author 2"],
+            "abstract": "Paper abstract",
+            "key_findings": ["Finding 1", "Finding 2", "Finding 3"],
+            "methodology": "Detailed description of methodology",
+            "results": "Summary of key results",
+            "conclusion": "Main conclusions",
+            "complexity_level": "beginner/intermediate/advanced",
+            "technical_terms": ["term1", "term2"],
+            "figures_tables": [
+                {{"type": "figure", "description": "Description", "content": "Content if available"}},
+                {{"type": "table", "description": "Description", "content": "Content if available"}}
+            ]
+        }}
+
+        Focus on extracting the most important and impactful findings. Be thorough but concise.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are an expert research paper analyzer with deep knowledge across multiple academic fields.",
+            },
+            {"role": "user", "content": analysis_prompt},
+        ]
+
+        response = await self.generate_response(messages, temperature=0.3)
+        # print(f"Raw response: {response}")  # Debugging line
+
+        try:
+            # Extract JSON from response by removing markdown code blocks
+            # Remove ```json at the start and ``` at the end
+            cleaned_response = re.sub(r'^```json\s*', '', response, flags=re.MULTILINE)
+            cleaned_response = re.sub(r'\s*```$', '', cleaned_response, flags=re.MULTILINE)
+            cleaned_response = cleaned_response.strip()
+            print(f"Cleaned response: {cleaned_response}")  # Debugging line
+
+            # Extract JSON from cleaned response
+            json_match = re.search(r"\{.*\}", cleaned_response, re.DOTALL)
+            if json_match:
+                analysis_data = json.loads(json_match.group())
+                return PaperAnalysis(**analysis_data)
+            raise ValueError("No valid JSON found in response")
+        except Exception:
+            # Fallback parsing
+            return self._fallback_parse(response, input_data.content)
+
+    def _fallback_parse(self, response: str, content: str) -> PaperAnalysis:
+        """Fallback parsing if JSON extraction fails"""
+        lines = content.split("\n")
+        title = next(
+            (line.strip() for line in lines if len(line.strip()) > 10), "Untitled Paper"
+        )
+
+        return PaperAnalysis(
+            title=title,
+            authors=["Unknown Author"],
+            abstract=content[:500] + "..." if len(content) > 500 else content,
+            key_findings=["Analysis in progress"],
+            methodology="To be analyzed",
+            results="To be analyzed",
+            conclusion="To be analyzed",
+            complexity_level="intermediate",
+            technical_terms=[],
+            figures_tables=[],
+        )

app/agents/poster_generator.py

@@ -0,0 +1,268 @@
+import os
+import subprocess
+import tempfile
+
+from app.agents.base_agent import BaseAgent
+from app.agents.poster_layout_analyzer import PosterLayoutAnalyzerAgent
+from app.models.schemas import PaperAnalysis, PosterContent
+from app.services.pdf_to_image_service import pdf_to_image_service
+
+
+class PosterGeneratorAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("PosterGenerator", model_type="coding")
+        self.template_dir = "app/templates/poster_templates"
+        self.layout_analyzer = PosterLayoutAnalyzerAgent()
+        self.max_fix_attempts = 2  # Maximum attempts to fix layout issues
+
+    async def process(
+        self,
+        analysis: PaperAnalysis,
+        template_type: str = "ieee",
+        orientation: str = "landscape",
+    ) -> PosterContent:
+        """Generate academic conference poster"""
+        # tikzdocumentation
+        tikzdocumentation = ""
+        with open(
+            os.path.join(self.template_dir, "tikzposter.md"),
+            encoding="utf-8",
+        ) as f:
+            tikzdocumentation = f.read()
+        # Generate LaTeX content
+        latex_prompt = f"""
+        Generate LaTeX code for an academic conference poster using the {template_type} style.
+        The poster should be suitable for a {orientation} orientation and include the following sections:
+        
+        Paper Details:
+        Title: {analysis.title}
+        Authors: {", ".join(analysis.authors)}
+        Abstract: {analysis.abstract}
+        Methodology: {analysis.methodology}
+        Results: {analysis.results}
+        Conclusion: {analysis.conclusion}
+        Key Findings: {", ".join(analysis.key_findings)}
+        
+        Requirements:
+        - Use tikzposter or beamerposter package
+        - Professional academic layout
+        - Clear sections: Abstract, Methodology, Results, Conclusion
+        - Include space for figures/tables
+        - Use appropriate fonts and colors for {template_type} style
+        - Make it visually appealing and readable
+        
+        Generate complete LaTeX code that can be compiled directly.
+        Use the tikzposter package for a modern academic poster design.
+        The poster should be structured with clear sections and headings.
+        Poster should be aesthetically pleasing with good theme and color choices. Given the documentation below, try to make the poster visually appealing and professional.
+        MAKE SURE THAT NONE OF THE SECTIONS ARE EMPTY OR MISSING OR GOES OUT OF THE POSTER.
+        For you reference here is the documentation for the tikzposter package:
+        {tikzdocumentation}
+        
+        Make sure you give your ouptut just a tex code block starting with ```latex and ending with ```.
+        Do not include any other text or explanations.
+        Here is an example of a simple poster template:
+        ```latex
+        # Your code goes here
+        ```
+
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a LaTeX expert specializing in academic poster design. Generate clean, compilable LaTeX code.",
+            },
+            {"role": "user", "content": latex_prompt},
+        ]
+
+        latex_code = await self.generate_response(messages, temperature=0.3)
+        latex_code = self._clean_latex_code(latex_code)
+
+        # Compile to PDF and analyze layout
+        pdf_path, final_latex_code = await self._compile_and_analyze_poster(
+            latex_code,
+            analysis.title,
+            analysis,
+        )
+
+        return PosterContent(
+            template_type=template_type,
+            title=analysis.title,
+            authors=", ".join(analysis.authors),
+            abstract=analysis.abstract,
+            methodology=analysis.methodology,
+            results=analysis.results,
+            conclusion=analysis.conclusion,
+            figures=[],  # Will be populated if figures are detected
+            latex_code=final_latex_code,
+            pdf_path=pdf_path,
+        )
+
+    def _clean_latex_code(self, latex_code: str) -> str:
+        """Clean and validate LaTeX code"""
+        # Remove markdown code block markers if present
+        latex_code = latex_code.replace("```latex", "").replace("```", "")
+
+        # Ensure document structure
+        if "\\documentclass" not in latex_code:
+            latex_code = "\\documentclass[a0paper,portrait]{tikzposter}\n" + latex_code
+
+        if "\\begin{document}" not in latex_code:
+            latex_code += "\n\\begin{document}\n\\maketitle\n\\end{document}"
+
+        return latex_code.strip()
+
+    async def _compile_latex(self, latex_code: str, title: str) -> str:
+        """Compile LaTeX to PDF"""
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                # Create LaTeX file
+                tex_file = os.path.join(temp_dir, "poster.tex")
+                with open(tex_file, "w", encoding="utf-8") as f:
+                    f.write(latex_code)
+
+                # Compile with pdflatex
+                result = subprocess.run(
+                    ["pdflatex", "-interaction=nonstopmode", "poster.tex"],
+                    cwd=temp_dir,
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+
+                pdf_file = os.path.join(temp_dir, "poster.pdf")
+
+                if os.path.exists(pdf_file):
+                    # Move to outputs directory
+                    output_dir = "outputs/posters"
+                    os.makedirs(output_dir, exist_ok=True)
+
+                    safe_title = "".join(
+                        c for c in title if c.isalnum() or c in (" ", "-", "_")
+                    ).rstrip()
+                    output_path = os.path.join(output_dir, f"{safe_title}_poster.pdf")
+
+                    import shutil
+
+                    shutil.copy2(pdf_file, output_path)
+                    return output_path
+                # Compilation failed, try with simpler template
+                return await self._generate_fallback_poster(latex_code, title)
+
+        except Exception as e:
+            print(f"LaTeX compilation error: {e}")
+            return await self._generate_fallback_poster(latex_code, title)
+
+    async def _generate_fallback_poster(self, latex_code: str, title: str) -> str:
+        """Generate a simple fallback poster if LaTeX compilation fails"""
+        try:
+            # Create a simple HTML poster as fallback
+            html_content = f"""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>{title}</title>
+                <style>
+                    body {{ font-family: Arial, sans-serif; margin: 20px; }}
+                    .poster {{ width: 800px; margin: 0 auto; }}
+                    .title {{ font-size: 24px; font-weight: bold; text-align: center; margin-bottom: 20px; }}
+                    .section {{ margin: 20px 0; padding: 15px; border: 1px solid #ccc; }}
+                    .section h3 {{ color: #333; }}
+                </style>
+            </head>
+            <body>
+                <div class="poster">
+                    <div class="title">{title}</div>
+                    <div class="section">
+                        <h3>LaTeX Code Generated</h3>
+                        <pre>{latex_code[:500]}...</pre>
+                    </div>
+                    <div class="section">
+                        <p>Note: PDF compilation failed. LaTeX code is available for manual compilation.</p>
+                    </div>
+                </div>
+            </body>
+            </html>
+            """
+
+            output_dir = "outputs/posters"
+            os.makedirs(output_dir, exist_ok=True)
+
+            safe_title = "".join(
+                c for c in title if c.isalnum() or c in (" ", "-", "_")
+            ).rstrip()
+            output_path = os.path.join(output_dir, f"{safe_title}_poster.html")
+
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(html_content)
+
+            return output_path
+
+        except Exception as e:
+            print(f"Fallback poster generation error: {e}")
+            return "outputs/posters/poster_generation_failed.txt"
+
+    async def _compile_and_analyze_poster(
+        self,
+        latex_code: str,
+        title: str,
+        analysis: PaperAnalysis,
+    ) -> tuple[str, str]:
+        """
+        Compile LaTeX to PDF and analyze layout, fixing issues if needed.
+
+        Returns:
+            tuple: (pdf_path, final_latex_code)
+
+        """
+        current_latex = latex_code
+        attempt = 0
+
+        while attempt <= self.max_fix_attempts:
+            # Compile to PDF
+            pdf_path = await self._compile_latex(current_latex, title)
+
+            if not pdf_path:
+                print(f"PDF compilation failed on attempt {attempt + 1}")
+                break
+
+            # Convert PDF to image for analysis (optimized resolution for vision model)
+            poster_image_path = await pdf_to_image_service.convert_pdf_to_image(
+                pdf_path,
+                max_width=800,  # Optimized for vision model token costs
+            )
+
+            if not poster_image_path:
+                print("Could not convert PDF to image for analysis")
+                return pdf_path, current_latex
+
+            # Analyze poster layout
+            (
+                fits_properly,
+                analysis_message,
+                fixed_latex,
+            ) = await self.layout_analyzer.analyze_poster_layout(
+                poster_image_path,
+                current_latex,
+                title,
+            )
+
+            print(f"Poster layout analysis (attempt {attempt + 1}): {analysis_message}")
+
+            if fits_properly:
+                print("Poster layout is satisfactory!")
+                return pdf_path, current_latex
+
+            if fixed_latex and attempt < self.max_fix_attempts:
+                print(f"Applying layout fixes (attempt {attempt + 1})...")
+                current_latex = self._clean_latex_code(fixed_latex)
+                attempt += 1
+            else:
+                print(
+                    "Max fix attempts reached or no fix available. Using current version.",
+                )
+                return pdf_path, current_latex
+
+        # If we reach here, return the last attempt
+        return pdf_path, current_latex

app/agents/poster_layout_analyzer.py

@@ -0,0 +1,166 @@
+import base64
+import os
+from typing import Optional, Tuple
+
+from app.agents.base_agent import BaseAgent
+
+
+class PosterLayoutAnalyzerAgent(BaseAgent):
+    """Agent to analyze poster layout and provide fixes for content that doesn't fit properly"""
+
+    def __init__(self):
+        super().__init__("PosterLayoutAnalyzer", model_type="coding")
+
+    async def analyze_poster_layout(
+        self,
+        poster_image_path: str,
+        latex_code: str,
+        paper_title: str,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Analyze poster layout from image and provide fixes if content doesn't fit
+
+        Returns:
+            - bool: Whether the poster fits properly
+            - str: Analysis message
+            - Optional[str]: Fixed LaTeX code if needed
+
+        """
+        try:
+            # Convert image to base64 for vision model
+            image_base64 = await self._image_to_base64(poster_image_path)
+
+            if not image_base64:
+                return False, "Could not process poster image", None
+
+            # Create analysis prompt
+            analysis_prompt = f"""
+            You are an expert in academic poster design and LaTeX formatting. 
+            Analyze this generated poster image and determine if all content fits properly within the page boundaries.
+            
+            Paper Title: {paper_title}
+            
+            Look for the following issues:
+            1. Text or content that extends beyond page margins
+            2. Overlapping text or sections
+            3. Cut-off content at the bottom or sides
+            4. Sections that are too cramped or unreadable
+            5. Any content that appears to be missing or truncated
+
+            Based on your analysis, provide:
+            1. A clear assessment of whether the poster fits properly (YES/NO)
+            2. Specific issues you identify (if any)
+            3. Recommendations for fixing layout issues
+            
+            Be detailed and specific about what you observe in the image.
+            """
+
+            messages = [
+                {
+                    "role": "system",
+                    "content": "You are an expert academic poster design analyst. Analyze poster layouts for proper formatting and content fit.",
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": analysis_prompt,
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/png;base64,{image_base64}",
+                            },
+                        },
+                    ],
+                },
+            ]
+
+            analysis_response = await self.generate_response(messages, temperature=0.3)
+
+            # Check if poster needs fixing
+            needs_fixing = (
+                "NO" in analysis_response.upper()
+                and "fits properly" in analysis_response
+            )
+            fits_properly = not needs_fixing
+
+            if needs_fixing:
+                # Generate fixed LaTeX code
+                fixed_latex = await self._generate_fixed_latex(
+                    latex_code, analysis_response
+                )
+                return fits_properly, analysis_response, fixed_latex
+            return fits_properly, analysis_response, None
+
+        except Exception as e:
+            return False, f"Error analyzing poster layout: {e!s}", None
+
+    async def _image_to_base64(self, image_path: str) -> Optional[str]:
+        """Convert image to base64 string"""
+        try:
+            if not os.path.exists(image_path):
+                print(f"Image file not found: {image_path}")
+                return None
+
+            with open(image_path, "rb") as image_file:
+                image_data = image_file.read()
+                base64_string = base64.b64encode(image_data).decode("utf-8")
+                return base64_string
+        except Exception as e:
+            print(f"Error converting image to base64: {e}")
+            return None
+
+    async def _generate_fixed_latex(self, original_latex: str, analysis: str) -> str:
+        """Generate fixed LaTeX code based on analysis"""
+        fix_prompt = f"""
+        Based on the poster layout analysis below, fix the LaTeX code to ensure all content fits properly within the page.
+        
+        Analysis of issues found:
+        {analysis}
+        
+        Original LaTeX Code:
+        {original_latex}
+        
+        Please provide a corrected version of the LaTeX code that addresses the layout issues.
+        Focus on:
+        1. Reducing font sizes if text is too large
+        2. Adjusting section spacing and margins
+        3. Making content more concise if needed
+        4. Optimizing layout structure
+        5. Ensuring proper tikzposter block sizing and positioning
+        6. Using appropriate column layouts
+        7. Adjusting text wrapping and line spacing
+        
+        Provide ONLY the corrected LaTeX code starting with \\documentclass and ending with \\end{{document}}.
+        Do not include any explanations or markdown formatting.
+        MAKE SURE THE ENTIRE POSTER CONTENT FITS PROPERLY ON THE PAGE.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a LaTeX expert specializing in fixing academic poster layouts. Generate clean, compilable LaTeX code that fits properly on the page.",
+            },
+            {
+                "role": "user",
+                "content": fix_prompt,
+            },
+        ]
+
+        fixed_latex = await self.generate_response(messages, temperature=0.2)
+
+        # Clean the response
+        fixed_latex = fixed_latex.replace("```latex", "").replace("```", "").strip()
+
+        return fixed_latex
+
+    async def process(self, input_data):
+        """Implementation of abstract method from BaseAgent"""
+        # This method can be used for batch processing if needed
+        return await self.analyze_poster_layout(
+            input_data.get("image_path"),
+            input_data.get("latex_code"),
+            input_data.get("title"),
+        )

app/agents/presentation_generator.py

@@ -0,0 +1,337 @@
+import subprocess
+import tempfile
+from pathlib import Path
+
+from app.agents.base_agent import BaseAgent
+from app.agents.presentation_planner import PresentationPlannerAgent
+from app.agents.presentation_visual_analyzer import PresentationVisualAnalyzerAgent
+from app.agents.tikz_diagram_generator import TikzDiagramAgent
+from app.models.schemas import PaperAnalysis, PresentationContent, PresentationPlan
+from app.services.presentation_pdf_to_image_service import (
+    presentation_pdf_to_image_service,
+)
+
+
+class PresentationGeneratorAgent(BaseAgent):
+    """Main agent for generating complete research presentations using Beamer"""
+
+    def __init__(self):
+        super().__init__("PresentationGenerator", model_type="coding")
+        self.template_dir = "app/templates/presentation_templates"
+        self.planner = PresentationPlannerAgent()
+        self.diagram_generator = TikzDiagramAgent()
+        self.visual_analyzer = PresentationVisualAnalyzerAgent()
+        self.max_iterations = 1
+
+    async def process(
+        self,
+        analysis: PaperAnalysis,
+        template_type: str = "academic",
+        max_slides: int = 15,
+    ) -> PresentationContent:
+        """Generate complete presentation from paper analysis"""
+        try:
+            # Step 1: Plan the presentation structure
+            print("Planning presentation structure...")
+            plan = await self.planner.process(analysis, max_slides)
+
+            # Step 2: Generate TikZ diagrams if needed
+            print("Generating diagrams...")
+            diagrams = []
+            if plan.suggested_diagrams:
+                diagrams = await self.diagram_generator.process(
+                    plan.suggested_diagrams,
+                    analysis,
+                )
+
+            # Step 3: Generate Beamer LaTeX code
+            print("Generating Beamer presentation...")
+            latex_code = await self._generate_beamer_presentation(
+                analysis,
+                plan,
+                diagrams,
+                template_type,
+            )
+
+            # Step 4: Compile and analyze presentation
+            print("Compiling and analyzing presentation...")
+            pdf_path, final_latex = await self._compile_and_analyze_presentation(
+                latex_code,
+                analysis.title,
+                plan,
+            )
+
+            return PresentationContent(
+                title=analysis.title,
+                authors=", ".join(analysis.authors),
+                institution=None,  # Could be extracted from paper if available
+                date=None,
+                template_type=template_type,
+                slides=plan.slides,
+                tikz_diagrams=diagrams,
+                latex_code=final_latex,
+                pdf_path=pdf_path,
+                total_slides=plan.total_slides,
+            )
+
+        except Exception as e:
+            print(f"Error generating presentation: {e}")
+            raise
+
+    async def _generate_beamer_presentation(
+        self,
+        analysis: PaperAnalysis,
+        plan: PresentationPlan,
+        diagrams: list,
+        template_type: str,
+    ) -> str:
+        """Generate complete Beamer LaTeX code"""
+        # Create diagram code mapping
+        diagram_codes = {d.diagram_id: d.tikz_code for d in diagrams}
+
+        beamer_prompt = f"""
+        Generate a complete Beamer LaTeX presentation based on this research paper analysis and slide plan.
+
+        Paper Information:
+        Title: {analysis.title}
+        Authors: {", ".join(analysis.authors)}
+        Abstract: {analysis.abstract}
+        
+        Presentation Plan:
+        Total Slides: {plan.total_slides}
+        Style: {plan.presentation_style}
+        Template: {template_type}
+
+        Slide Details:
+        {self._format_slide_plan(plan.slides)}
+
+        Available TikZ Diagrams:
+        {self._format_diagram_info(diagrams)}
+
+        Requirements:
+        1. Use Beamer document class with appropriate theme
+        2. Include all necessary packages (tikz, graphicx, etc.)
+        3. Create professional academic presentation
+        4. Use consistent formatting and styling
+        5. Include proper section breaks and navigation
+        6. Integrate TikZ diagrams where appropriate
+        7. Use appropriate font sizes and spacing
+        8. Follow Beamer best practices
+        9. Choose the color scheme such that all the text are readable and visually appealing
+        10. If there are too many content on a slide, split it into multiple slides
+        11. Ensure all diagrams are properly labeled and referenced in the text
+        12. No content should go out of the slide boundaries
+
+        Template Style Guidelines:
+        - Academic: Clean, professional, blue color scheme
+        - Corporate: Modern, sleek, with company-like styling  
+        - Minimal: Simple, clean, minimal visual elements
+
+        Generate complete LaTeX code starting with \\documentclass{{beamer}} and ending with \\end{{document}}.
+        Include all slide content, proper formatting, and TikZ diagrams.
+        Make sure each slide is well-designed and informative.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a Beamer LaTeX expert specializing in creating professional academic presentations. Generate clean, compilable code.",
+            },
+            {"role": "user", "content": beamer_prompt},
+        ]
+
+        latex_code = await self.generate_response(messages, temperature=0.3)
+        return self._clean_latex_code(latex_code)
+
+    def _format_slide_plan(self, slides) -> str:
+        """Format slide plan for the prompt"""
+        formatted = ""
+        for slide in slides:
+            formatted += f"""
+Slide {slide.slide_number}: {slide.title}
+Type: {slide.slide_type}
+Content: {slide.content}
+TikZ Diagrams: {", ".join(slide.tikz_diagrams) if slide.tikz_diagrams else "None"}
+Notes: {slide.notes or "None"}
+---"""
+        return formatted
+
+    def _format_diagram_info(self, diagrams) -> str:
+        """Format diagram information for the prompt"""
+        if not diagrams:
+            return "No diagrams available"
+
+        formatted = ""
+        for diagram in diagrams:
+            formatted += f"""
+{diagram.diagram_id}: {diagram.title}
+Description: {diagram.description}
+Type: {diagram.diagram_type}
+---"""
+        return formatted
+
+    def _clean_latex_code(self, latex_code: str) -> str:
+        """Clean and validate Beamer LaTeX code"""
+        # Remove markdown code blocks if present
+        latex_code = latex_code.replace("```latex", "").replace("```", "")
+
+        # Ensure document structure
+        if "\\documentclass" not in latex_code:
+            latex_code = "\\documentclass{beamer}\n" + latex_code
+
+        if "\\begin{document}" not in latex_code:
+            latex_code += "\n\\begin{document}\n\\end{document}"
+
+        return latex_code.strip()
+
+    async def _compile_latex(self, latex_code: str, title: str) -> str:
+        """Compile Beamer LaTeX to PDF"""
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                # Clean title for filename
+                safe_title = "".join(
+                    c for c in title if c.isalnum() or c in (" ", "-", "_")
+                ).rstrip()
+                safe_title = safe_title.replace(" ", "_")[:50]
+
+                # Write LaTeX file
+                tex_file = Path(temp_dir) / f"{safe_title}_presentation.tex"
+                tex_file.write_text(latex_code, encoding="utf-8")
+
+                # Compile with pdflatex (multiple passes for references)
+                for _ in range(2):
+                    result = subprocess.run(
+                        ["pdflatex", "-interaction=nonstopmode", str(tex_file)],
+                        cwd=temp_dir,
+                        capture_output=True,
+                        text=True,
+                        timeout=60,
+                        check=False,
+                    )
+
+                pdf_file = tex_file.with_suffix(".pdf")
+                if pdf_file.exists():
+                    # Copy to outputs directory
+                    output_path = Path("outputs/presentations")
+                    output_path.mkdir(exist_ok=True)
+
+                    final_pdf = output_path / f"{safe_title}_presentation.pdf"
+                    final_pdf.write_bytes(pdf_file.read_bytes())
+
+                    return str(final_pdf)
+                print(f"PDF compilation failed. LaTeX output: {result.stdout}")
+                print(f"LaTeX errors: {result.stderr}")
+                return None
+
+        except Exception as e:
+            print(f"Error compiling presentation: {e}")
+            return None
+
+    async def _compile_and_analyze_presentation(
+        self,
+        latex_code: str,
+        title: str,
+        plan: PresentationPlan,
+    ) -> tuple[str, str]:
+        """Compile presentation and analyze visual quality"""
+        current_latex = latex_code
+        iteration = 0
+
+        while iteration < self.max_iterations:
+            # Compile to PDF
+            pdf_path = await self._compile_latex(current_latex, title)
+
+            if not pdf_path:
+                print(f"PDF compilation failed on iteration {iteration + 1}")
+                break
+
+            # Analyze at least half of the slides for comprehensive quality assessment
+            print(f"Analyzing presentation quality (iteration {iteration + 1})...")
+
+            # Calculate pages to analyze (at least half, minimum 1)
+            pages_to_analyze = max(1, plan.total_slides // 2)
+            if pages_to_analyze < plan.total_slides // 2:
+                pages_to_analyze = plan.total_slides // 2 + 1
+
+            print(f"Analyzing {pages_to_analyze} out of {plan.total_slides} slides...")
+
+            # Analyze multiple slides for comprehensive assessment
+            all_analyses = []
+            improvement_suggestions = []
+            slides_analyzed = 0
+            quality_threshold = (
+                0.7  # Consider presentation good if 70% of slides are good
+            )
+
+            for page_num in range(1, min(pages_to_analyze + 1, plan.total_slides + 1)):
+                slide_image_path = (
+                    await presentation_pdf_to_image_service.convert_pdf_to_image(
+                        pdf_path,
+                        page_number=page_num,
+                        max_width=1024,
+                    )
+                )
+
+                if slide_image_path:
+                    (
+                        is_good,
+                        analysis,
+                        improved_latex,
+                    ) = await self.visual_analyzer.analyze_presentation_layout(
+                        slide_image_path,
+                        current_latex,
+                        page_num,
+                        plan.total_slides,
+                    )
+
+                    all_analyses.append((page_num, is_good, analysis))
+                    if improved_latex and not is_good:
+                        improvement_suggestions.append(improved_latex)
+
+                    slides_analyzed += 1
+                    print(
+                        f"Slide {page_num}: {'✅ Good' if is_good else '❌ Needs improvement'}"
+                    )
+                else:
+                    print(f"Could not generate image for slide {page_num}")
+
+            if slides_analyzed == 0:
+                print("Could not analyze any slides - using current version")
+                return pdf_path, current_latex
+
+            # Determine overall quality based on analyzed slides
+            good_slides = sum(1 for _, is_good, _ in all_analyses if is_good)
+            quality_ratio = good_slides / slides_analyzed
+
+            print(
+                f"Quality assessment: {good_slides}/{slides_analyzed} slides are good ({quality_ratio:.1%})"
+            )
+
+            # Consider presentation good if quality meets threshold
+            if quality_ratio >= quality_threshold:
+                print("Overall presentation quality is satisfactory!")
+                return pdf_path, current_latex
+
+            # Apply improvements if available and not at max iterations
+            if improvement_suggestions and iteration < self.max_iterations - 1:
+                print(f"Applying visual improvements (iteration {iteration + 1})...")
+                # Use the most recent improvement suggestion
+                current_latex = self._clean_latex_code(improvement_suggestions[-1])
+                iteration += 1
+            else:
+                print("Max iterations reached or no improvements available.")
+                return pdf_path, current_latex
+
+        return pdf_path, current_latex
+
+    async def create_template_variants(self, analysis: PaperAnalysis) -> dict:
+        """Create presentations with different templates for comparison"""
+        templates = ["academic", "corporate", "minimal"]
+        presentations = {}
+
+        for template in templates:
+            print(f"Generating {template} template presentation...")
+            presentation = await self.process(analysis, template_type=template)
+            presentations[template] = presentation
+
+        return presentations

app/agents/presentation_planner.py

@@ -0,0 +1,209 @@
+from app.agents.base_agent import BaseAgent
+from app.models.schemas import PaperAnalysis, PresentationPlan, SlideContent
+
+
+class PresentationPlannerAgent(BaseAgent):
+    """Agent to plan presentation structure and content based on paper analysis"""
+
+    def __init__(self):
+        super().__init__("PresentationPlanner", model_type="heavy")
+
+    async def process(
+        self, analysis: PaperAnalysis, max_slides: int = 15
+    ) -> PresentationPlan:
+        """Create a detailed plan for the presentation slides"""
+        planning_prompt = f"""
+        You are an expert presentation planner specializing in academic research presentations. 
+        Create a detailed slide-by-slide plan for a {max_slides}-slide presentation based on this research paper analysis.
+
+        Paper Analysis:
+        Title: {analysis.title}
+        Authors: {", ".join(analysis.authors)}
+        Abstract: {analysis.abstract}
+        Key Findings: {", ".join(analysis.key_findings)}
+        Methodology: {analysis.methodology}
+        Results: {analysis.results}
+        Conclusion: {analysis.conclusion}
+        Complexity Level: {analysis.complexity_level}
+        Technical Terms: {", ".join(analysis.technical_terms)}
+
+        Create a presentation plan with the following structure:
+        1. Title slide
+        2. Agenda/Outline
+        3. Introduction/Background (1-2 slides)
+        4. Problem Statement/Motivation (1 slide)
+        5. Methodology (2-3 slides)
+        6. Results (3-4 slides)
+        7. Key Findings (1-2 slides)
+        8. Implications/Discussion (1-2 slides)
+        9. Conclusion (1 slide)
+        10. Future Work/Q&A (1 slide)
+
+        For each slide, provide:
+        - Slide number
+        - Title
+        - Detailed content description (what should be on the slide)
+        - Slide type (title, content, image, diagram, conclusion)
+        - Any speaker notes
+        - Suggestions for tikz diagrams if applicable
+
+        Also suggest specific diagrams that would enhance the presentation:
+        - Flowcharts for methodology
+        - Architecture diagrams for systems
+        - Comparison charts for results
+        - Timeline diagrams for processes
+        - Graphs for statistical data
+
+        Try to put the content in the slides in a way that is engaging and informative, while also being concise.
+        Don't put too much text on each slide; focus on key points and visuals.
+        Understand that the slides are small and too much text will overflow from the slides making them look cluttered.
+        
+
+        Respond in this JSON format:
+        {{
+            "total_slides": {max_slides},
+            "slides": [
+                {{
+                    "slide_number": 1,
+                    "title": "Slide Title",
+                    "content": "Detailed content description",
+                    "slide_type": "title|content|image|diagram|conclusion",
+                    "notes": "Speaker notes or additional information",
+                    "tikz_diagrams": ["description of tikz diagram if needed"]
+                }}
+            ],
+            "suggested_diagrams": ["List of diagrams to create"],
+            "presentation_style": "academic"
+        }}
+
+        Make the presentation engaging, well-structured, and appropriate for an academic audience.
+        Ensure content flows logically and each slide has a clear purpose.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are an expert academic presentation planner with deep knowledge of effective presentation design and research communication.",
+            },
+            {"role": "user", "content": planning_prompt},
+        ]
+
+        response = await self.generate_response(messages, temperature=0.4)
+
+        try:
+            # Clean and parse JSON response
+            import json
+            import re
+
+            # Remove markdown code blocks if present
+            cleaned_response = re.sub(r"^```json\s*", "", response, flags=re.MULTILINE)
+            cleaned_response = re.sub(
+                r"\s*```$", "", cleaned_response, flags=re.MULTILINE
+            )
+            cleaned_response = cleaned_response.strip()
+
+            # Extract JSON from cleaned response
+            json_match = re.search(r"\{.*\}", cleaned_response, re.DOTALL)
+            if json_match:
+                plan_data = json.loads(json_match.group())
+
+                # Convert slides data to SlideContent objects
+                slides = []
+                for slide_data in plan_data.get("slides", []):
+                    slides.append(SlideContent(**slide_data))
+
+                return PresentationPlan(
+                    total_slides=plan_data.get("total_slides", max_slides),
+                    slides=slides,
+                    suggested_diagrams=plan_data.get("suggested_diagrams", []),
+                    presentation_style=plan_data.get("presentation_style", "academic"),
+                )
+            raise ValueError("No valid JSON found in response")
+
+        except Exception as e:
+            print(f"Error parsing presentation plan: {e}")
+            # Fallback plan
+            return self._create_fallback_plan(analysis, max_slides)
+
+    def _create_fallback_plan(
+        self, analysis: PaperAnalysis, max_slides: int
+    ) -> PresentationPlan:
+        """Create a basic fallback presentation plan"""
+        slides = [
+            SlideContent(
+                slide_number=1,
+                title=analysis.title,
+                content=f"Authors: {', '.join(analysis.authors)}",
+                slide_type="title",
+                notes="Title slide with paper title and authors",
+            ),
+            SlideContent(
+                slide_number=2,
+                title="Agenda",
+                content="Presentation outline: Introduction, Methodology, Results, Conclusion",
+                slide_type="content",
+                notes="Overview of presentation structure",
+            ),
+            SlideContent(
+                slide_number=3,
+                title="Introduction",
+                content=analysis.abstract[:300] + "..."
+                if len(analysis.abstract) > 300
+                else analysis.abstract,
+                slide_type="content",
+                notes="Introduction based on paper abstract",
+            ),
+            SlideContent(
+                slide_number=4,
+                title="Methodology",
+                content=analysis.methodology[:400] + "..."
+                if len(analysis.methodology) > 400
+                else analysis.methodology,
+                slide_type="content",
+                notes="Research methodology and approach",
+            ),
+            SlideContent(
+                slide_number=5,
+                title="Key Findings",
+                content="\n".join(
+                    [f"• {finding}" for finding in analysis.key_findings[:3]]
+                ),
+                slide_type="content",
+                notes="Main research findings",
+            ),
+            SlideContent(
+                slide_number=6,
+                title="Results",
+                content=analysis.results[:400] + "..."
+                if len(analysis.results) > 400
+                else analysis.results,
+                slide_type="content",
+                notes="Research results and outcomes",
+            ),
+            SlideContent(
+                slide_number=7,
+                title="Conclusion",
+                content=analysis.conclusion[:300] + "..."
+                if len(analysis.conclusion) > 300
+                else analysis.conclusion,
+                slide_type="conclusion",
+                notes="Conclusions and implications",
+            ),
+            SlideContent(
+                slide_number=8,
+                title="Thank You",
+                content="Questions & Discussion",
+                slide_type="conclusion",
+                notes="Q&A slide",
+            ),
+        ]
+
+        return PresentationPlan(
+            total_slides=len(slides),
+            slides=slides,
+            suggested_diagrams=[
+                "Research methodology flowchart",
+                "Results comparison chart",
+            ],
+            presentation_style="academic",
+        )

app/agents/presentation_visual_analyzer.py

@@ -0,0 +1,316 @@
+import base64
+import os
+from typing import Optional, Tuple
+
+from app.agents.base_agent import BaseAgent
+
+
+class PresentationVisualAnalyzerAgent(BaseAgent):
+    """Agent to analyze presentation layout and visual elements for quality assurance"""
+
+    def __init__(self):
+        super().__init__("PresentationVisualAnalyzer", model_type="light")
+
+    async def analyze_presentation_layout(
+        self,
+        presentation_image_path: str,
+        latex_code: str,
+        slide_number: int,
+        total_slides: int,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Analyze presentation slide layout and provide feedback
+
+        Returns:
+            tuple: (is_layout_good, analysis_feedback, suggested_fixes)
+
+        """
+        try:
+            # Convert image to base64 for vision model
+            image_base64 = await self._image_to_base64(presentation_image_path)
+            if not image_base64:
+                return False, "Could not process presentation image", None
+
+            analysis_prompt = f"""
+            Analyze this presentation slide (slide {slide_number} of {total_slides}) for layout quality and visual appeal.
+
+            Look for the following aspects:
+            1. Text readability and font sizes
+            2. Content overflow or text cut-off
+            3. Proper spacing and margins
+            4. Visual hierarchy and organization
+            5. Color scheme and contrast
+            6. Diagram/image clarity and positioning
+            7. Overall professional appearance
+            8. Slide balance and composition
+
+            Specific issues to check:
+            - Is all text clearly visible and readable?
+            - Are there any overlapping elements?
+            - Is the content well-organized and not cramped?
+            - Are diagrams and images properly sized and positioned?
+            - Is the slide visually appealing and professional?
+            - Does the slide follow good presentation design principles?
+
+            Provide a detailed assessment including:
+            1. Overall quality rating (Excellent/Good/Fair/Poor)
+            2. Specific issues identified (if any)
+            3. Recommendations for improvement
+            4. Whether the slide needs to be regenerated
+
+            There are a lot of cases where the sentences are not fitting in the slide, it looks like it is the end of the sentence, but some part of the sentence is cut off. Make sure to find those cases and provide feedback on them. THESE FEEDBACKS SHOULD BE WRITTEN IN CAPITAL.
+
+            Be thorough in your analysis and provide actionable feedback.
+            """
+
+            messages = [
+                {
+                    "role": "system",
+                    "content": "You are an expert presentation design analyst with deep knowledge of visual design principles and academic presentation standards.",
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": analysis_prompt,
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/png;base64,{image_base64}",
+                            },
+                        },
+                    ],
+                },
+            ]
+
+            analysis_response = await self.generate_response(messages, temperature=0.3)
+
+            # Determine if layout needs improvement
+            needs_improvement = any(
+                keyword in analysis_response.lower()
+                for keyword in [
+                    "poor",
+                    "fair",
+                    "cramped",
+                    "overflow",
+                    "cut-off",
+                    "overlapping",
+                    "unreadable",
+                    "too small",
+                    "needs improvement",
+                    "regenerate",
+                ]
+            )
+
+            layout_is_good = not needs_improvement
+
+            if needs_improvement:
+                # Generate specific fixes
+                fixed_latex = await self._generate_layout_fixes(
+                    latex_code, analysis_response
+                )
+                return layout_is_good, analysis_response, fixed_latex
+
+            return layout_is_good, analysis_response, None
+
+        except Exception as e:
+            return False, f"Error analyzing presentation layout: {e!s}", None
+
+    async def _image_to_base64(self, image_path: str) -> Optional[str]:
+        """Convert image to base64 string"""
+        try:
+            if not os.path.exists(image_path):
+                print(f"Presentation image not found: {image_path}")
+                return None
+
+            with open(image_path, "rb") as image_file:
+                image_data = image_file.read()
+                base64_string = base64.b64encode(image_data).decode("utf-8")
+                return base64_string
+        except Exception as e:
+            print(f"Error converting presentation image to base64: {e}")
+            return None
+
+    async def _generate_layout_fixes(self, original_latex: str, analysis: str) -> str:
+        """Generate improved LaTeX code based on visual analysis"""
+        fix_prompt = f"""
+        Based on the presentation layout analysis below, improve the Beamer LaTeX code to fix visual and layout issues.
+        
+        Visual Analysis Feedback:
+        {analysis}
+        
+        Original LaTeX Code:
+        {original_latex}
+        
+        Please provide an improved version that addresses the identified issues. Focus on:
+        1. Improving text readability (font sizes, spacing)
+        2. Fixing content overflow or cut-off issues
+        3. Better spacing and margins
+        4. Improved visual hierarchy
+        5. Better positioning of elements
+        6. Professional color scheme
+        7. Proper slide layout and composition
+        
+        Beamer-specific improvements:
+        - Use appropriate frame options for content fitting
+        - Adjust font sizes with \\tiny, \\small, \\large, etc.
+        - Use proper column layouts for better organization
+        - Apply appropriate themes and color schemes
+        - Use proper spacing commands (\\vspace, \\hspace)
+        - Ensure TikZ diagrams fit properly on slides
+        
+        Provide ONLY the corrected Beamer LaTeX code.
+        Do not include explanations or markdown formatting.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a Beamer LaTeX expert specializing in presentation layout optimization and visual design improvements.",
+            },
+            {
+                "role": "user",
+                "content": fix_prompt,
+            },
+        ]
+
+        fixed_latex = await self.generate_response(messages, temperature=0.2)
+
+        # Clean the response
+        fixed_latex = fixed_latex.replace("```latex", "").replace("```", "").strip()
+
+        return fixed_latex
+
+    async def analyze_diagram_quality(
+        self,
+        diagram_image_path: str,
+        tikz_code: str,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """Analyze the quality of TikZ diagrams in presentations"""
+        try:
+            image_base64 = await self._image_to_base64(diagram_image_path)
+            if not image_base64:
+                return False, "Could not process diagram image", None
+
+            diagram_prompt = """
+            Analyze this TikZ diagram for clarity, readability, and visual appeal in a presentation context.
+
+            Check for:
+            1. Clarity and readability of text and labels
+            2. Appropriate sizing for presentation slides
+            3. Good color choices and contrast
+            4. Proper spacing between elements
+            5. Professional appearance
+            6. Clear visual hierarchy
+            7. Effective use of shapes and arrows
+
+            Provide feedback on:
+            - Overall diagram quality
+            - Specific improvements needed
+            - Whether the diagram enhances understanding
+            - Recommendations for better visual design
+            """
+
+            messages = [
+                {
+                    "role": "system",
+                    "content": "You are an expert in diagram design and TikZ visualization for academic presentations.",
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": diagram_prompt,
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/png;base64,{image_base64}",
+                            },
+                        },
+                    ],
+                },
+            ]
+
+            analysis = await self.generate_response(messages, temperature=0.3)
+
+            needs_improvement = any(
+                keyword in analysis.lower()
+                for keyword in [
+                    "poor",
+                    "unclear",
+                    "hard to read",
+                    "too small",
+                    "cramped",
+                    "needs improvement",
+                    "confusing",
+                    "messy",
+                ]
+            )
+
+            is_good = not needs_improvement
+
+            if needs_improvement:
+                improved_tikz = await self._improve_tikz_diagram(tikz_code, analysis)
+                return is_good, analysis, improved_tikz
+
+            return is_good, analysis, None
+
+        except Exception as e:
+            return False, f"Error analyzing diagram: {e!s}", None
+
+    async def _improve_tikz_diagram(self, original_tikz: str, analysis: str) -> str:
+        """Improve TikZ diagram code based on analysis"""
+        improvement_prompt = f"""
+        Improve this TikZ diagram code based on the visual analysis feedback.
+        
+        Analysis Feedback:
+        {analysis}
+        
+        Original TikZ Code:
+        {original_tikz}
+        
+        Create an improved version that:
+        - Has better readability and clarity
+        - Uses appropriate sizing for presentations
+        - Has good color choices and contrast
+        - Is well-organized and professional
+        - Follows TikZ best practices
+        
+        Provide only the improved TikZ code within tikzpicture environment.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a TikZ expert focused on creating clear, professional diagrams for presentations.",
+            },
+            {
+                "role": "user",
+                "content": improvement_prompt,
+            },
+        ]
+
+        improved_tikz = await self.generate_response(messages, temperature=0.2)
+
+        # Clean the response
+        improved_tikz = (
+            improved_tikz.replace("```latex", "")
+            .replace("```tikz", "")
+            .replace("```", "")
+            .strip()
+        )
+
+        return improved_tikz
+
+    async def process(self, input_data):
+        """Implementation of abstract method from BaseAgent"""
+        return await self.analyze_presentation_layout(
+            input_data.get("image_path"),
+            input_data.get("latex_code"),
+            input_data.get("slide_number", 1),
+            input_data.get("total_slides", 1),
+        )

app/agents/publisher.py

@@ -0,0 +1,6 @@
+from app.agents.base_agent import BaseAgent
+
+
+class PublisherAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("Publisher", model_type="light")

app/agents/tikz_diagram_generator.py

@@ -0,0 +1,162 @@
+from app.agents.base_agent import BaseAgent
+from app.models.schemas import PaperAnalysis, TikzDiagram
+
+
+class TikzDiagramAgent(BaseAgent):
+    """Agent to create TikZ-based diagrams and infographics for presentations"""
+
+    def __init__(self):
+        super().__init__("TikzDiagramGenerator", model_type="coding")
+
+    async def process(
+        self, diagram_descriptions: list[str], analysis: PaperAnalysis
+    ) -> list[TikzDiagram]:
+        """Generate TikZ diagrams based on descriptions and paper content"""
+        diagrams = []
+        for i, description in enumerate(diagram_descriptions):
+            diagram = await self._create_single_diagram(description, analysis, i + 1)
+            if diagram:
+                diagrams.append(diagram)
+
+        return diagrams
+
+    async def _create_single_diagram(
+        self, description: str, analysis: PaperAnalysis, diagram_num: int
+    ) -> TikzDiagram:
+        """Create a single TikZ diagram"""
+        tikz_prompt = f"""
+        Create a TikZ diagram for a research presentation based on this description and paper content.
+
+        Diagram Description: {description}
+
+        Paper Context:
+        Title: {analysis.title}
+        Methodology: {analysis.methodology}
+        Key Findings: {", ".join(analysis.key_findings)}
+        Results: {analysis.results}
+        Technical Terms: {", ".join(analysis.technical_terms)}
+
+        Generate clean, professional TikZ code that:
+        1. Is suitable for academic presentations
+        2. Uses appropriate colors and styling
+        3. Is well-commented for clarity
+        4. Fits within slide dimensions
+        5. Uses clear, readable fonts
+        6. Follows TikZ best practices
+
+        Common diagram types to consider:
+        - Flowcharts for processes/methodology
+        - Block diagrams for system architecture  
+        - Graphs and charts for data visualization
+        - Timeline diagrams for sequential processes
+        - Comparison diagrams for before/after scenarios
+        - Network diagrams for connections/relationships
+
+        Provide ONLY the TikZ code within a tikzpicture environment, without document structure.
+        Use appropriate TikZ libraries like shapes, arrows, positioning, etc.
+
+        Example format:
+        \\begin{{tikzpicture}}[node distance=2cm, auto]
+        % Your TikZ code here
+        \\end{{tikzpicture}}
+
+        Make the diagram informative, visually appealing, and directly relevant to the research content.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a TikZ expert specializing in creating academic diagrams and visualizations. Generate clean, professional TikZ code.",
+            },
+            {"role": "user", "content": tikz_prompt},
+        ]
+
+        response = await self.generate_response(messages, temperature=0.3)
+
+        # Clean the TikZ code
+        tikz_code = self._clean_tikz_code(response)
+
+        # Determine diagram type from description
+        diagram_type = self._determine_diagram_type(description)
+
+        return TikzDiagram(
+            diagram_id=f"diagram_{diagram_num}",
+            title=f"Diagram {diagram_num}",
+            description=description,
+            tikz_code=tikz_code,
+            diagram_type=diagram_type,
+        )
+
+    def _clean_tikz_code(self, code: str) -> str:
+        """Clean and validate TikZ code"""
+        # Remove markdown code blocks if present
+        code = code.replace("```latex", "").replace("```tikz", "").replace("```", "")
+
+        # Ensure tikzpicture environment
+        if "\\begin{tikzpicture}" not in code:
+            # Wrap content in tikzpicture if not present
+            code = f"\\begin{{tikzpicture}}[node distance=2cm, auto]\n{code}\n\\end{{tikzpicture}}"
+
+        return code.strip()
+
+    def _determine_diagram_type(self, description: str) -> str:
+        """Determine diagram type from description"""
+        description_lower = description.lower()
+
+        if any(
+            word in description_lower
+            for word in ["flow", "process", "step", "workflow"]
+        ):
+            return "flowchart"
+        if any(
+            word in description_lower
+            for word in ["architecture", "system", "structure", "framework"]
+        ):
+            return "architecture"
+        if any(
+            word in description_lower
+            for word in ["timeline", "sequence", "chronological", "time"]
+        ):
+            return "timeline"
+        if any(
+            word in description_lower
+            for word in ["comparison", "vs", "versus", "compare", "before", "after"]
+        ):
+            return "comparison"
+        if any(
+            word in description_lower
+            for word in ["graph", "chart", "plot", "data", "statistics"]
+        ):
+            return "graph"
+        if any(
+            word in description_lower
+            for word in ["network", "connection", "relationship", "link"]
+        ):
+            return "network"
+        return "general"
+
+    async def create_methodology_flowchart(
+        self, analysis: PaperAnalysis
+    ) -> TikzDiagram:
+        """Create a specific methodology flowchart"""
+        return await self._create_single_diagram(
+            f"Methodology flowchart showing the research process: {analysis.methodology}",
+            analysis,
+            1,
+        )
+
+    async def create_results_comparison(self, analysis: PaperAnalysis) -> TikzDiagram:
+        """Create a results comparison diagram"""
+        return await self._create_single_diagram(
+            f"Results comparison chart based on: {analysis.results}",
+            analysis,
+            2,
+        )
+
+    async def create_architecture_diagram(self, analysis: PaperAnalysis) -> TikzDiagram:
+        """Create a system architecture diagram"""
+        return await self._create_single_diagram(
+            f"System architecture diagram for the proposed approach in: {analysis.methodology}",
+            analysis,
+            3,
+        )

app/agents/tldr_generator.py

@@ -0,0 +1,172 @@
+from app.agents.base_agent import BaseAgent
+from app.models.schemas import PaperAnalysis, TLDRContent
+from app.services.image_service import image_service
+
+
+class TLDRGeneratorAgent(BaseAgent):
+    def __init__(self):
+        super().__init__("TLDRGenerator", model_type="light")
+
+    async def process(self, analysis: PaperAnalysis) -> TLDRContent:
+        """Generate platform-specific social media content"""
+        # LinkedIn Post
+        linkedin_prompt = f"""
+        Create a professional LinkedIn post about this research:
+        
+        Title: {analysis.title}
+        Key Findings: {", ".join(analysis.key_findings)}
+        Methodology: {analysis.methodology}
+        
+        Requirements:
+        - Professional tone
+        - 1200 characters max
+        - Include relevant hashtags
+        - Encourage engagement
+        - Highlight practical implications
+        Make sure to include the key findings and methodology in bullet fashion.
+        Don't include any other information except the post content. No additional headers or ending text in the response.
+        """
+
+        # Twitter Thread
+        twitter_prompt = f"""
+        Create a Twitter thread (3-5 tweets) about this research:
+        
+        Title: {analysis.title}
+        Key Findings: {", ".join(analysis.key_findings)}
+        Methodology: {analysis.methodology}
+
+        Requirements:
+        - Each tweet max 280 characters
+        - Start with hook
+        - Include thread numbers (1/n)
+        - End with call to action
+
+        Make sure to include the key findings and methodology.
+        Don't include any other information except the thread content. No additional headers or ending text in the response.
+        """
+
+        # Facebook Post
+        facebook_prompt = f"""
+        Create an engaging Facebook post about this research:
+        
+        Title: {analysis.title}
+        Key Finding: {analysis.key_findings if analysis.key_findings else analysis.conclusion}
+        Methodology: {analysis.methodology}
+
+        Requirements:
+        - Conversational tone
+        - Ask questions to encourage comments
+        - Include emojis appropriately
+        - 500 characters max
+
+        Make sure to include the key findings and methodology.
+        Don't include any other information except the post content. No additional headers or ending text in the response.
+        """
+
+        # Instagram Caption
+        instagram_prompt = f"""
+        Create an Instagram caption about this research:
+        
+        Title: {analysis.title}
+        Key Finding: {analysis.key_findings if analysis.key_findings else analysis.conclusion}
+        Methodology: {analysis.methodology}
+
+        Requirements:
+        - Visual-friendly language
+        - Include relevant emojis
+        - Use line breaks for readability
+        - Include hashtags
+        - 2200 characters max
+
+        Make sure to include the key findings and methodology.
+        Don't include any other information except the caption content. No additional headers or ending text in the response.
+        """
+
+        # Generate all content
+        linkedin_post = await self._generate_platform_content(linkedin_prompt)
+        twitter_thread = await self._generate_twitter_thread(twitter_prompt)
+        facebook_post = await self._generate_platform_content(facebook_prompt)
+        instagram_caption = await self._generate_platform_content(instagram_prompt)
+        hashtags = self._generate_hashtags(analysis)
+
+        # Generate images for all platforms
+        try:
+            images = await image_service.generate_all_social_images(analysis)
+        except Exception as e:
+            print(f"Error generating images: {e!s}")
+            images = {
+                "linkedin": None,
+                "twitter": None,
+                "facebook": None,
+                "instagram": None,
+            }
+
+        return TLDRContent(
+            linkedin_post=linkedin_post,
+            twitter_thread=twitter_thread,
+            facebook_post=facebook_post,
+            instagram_caption=instagram_caption,
+            hashtags=hashtags,
+            linkedin_image=images.get("linkedin"),
+            twitter_image=images.get("twitter"),
+            facebook_image=images.get("facebook"),
+            instagram_image=images.get("instagram"),
+        )
+
+    async def _generate_platform_content(self, prompt: str) -> str:
+        """Generate content for a specific platform"""
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a social media expert who creates engaging, platform-specific content.",
+            },
+            {"role": "user", "content": prompt},
+        ]
+        return await self.generate_response(messages, temperature=0.8)
+
+    async def _generate_twitter_thread(self, prompt: str) -> list:
+        """Generate Twitter thread as list of tweets"""
+        response = await self._generate_platform_content(prompt)
+
+        # Split into individual tweets
+        tweets = []
+        lines = response.split("\n")
+        current_tweet = ""
+
+        for line in lines:
+            line = line.strip()
+            if line and (
+                line.startswith(("1/", "2/", "3/", "4/", "5/"))
+                or line.startswith(("1.", "2.", "3.", "4.", "5."))
+            ):
+                if current_tweet:
+                    tweets.append(current_tweet.strip())
+                current_tweet = line
+            elif line:
+                current_tweet += " " + line
+
+        if current_tweet:
+            tweets.append(current_tweet.strip())
+
+        return tweets[:5]  # Limit to 5 tweets
+
+    def _generate_hashtags(self, analysis: PaperAnalysis) -> list:
+        """Generate relevant hashtags"""
+        hashtags = ["#research", "#science", "#academic"]
+
+        # Add field-specific hashtags
+        title_lower = analysis.title.lower()
+        if "ai" in title_lower or "artificial intelligence" in title_lower:
+            hashtags.extend(["#AI", "#MachineLearning", "#Technology"])
+        elif "machine learning" in title_lower:
+            hashtags.extend(["#MachineLearning", "#DataScience", "#AI"])
+        elif "computer" in title_lower:
+            hashtags.extend(["#ComputerScience", "#Technology", "#Programming"])
+        elif "biology" in title_lower or "medical" in title_lower:
+            hashtags.extend(["#Biology", "#Medicine", "#Healthcare"])
+        elif "physics" in title_lower:
+            hashtags.extend(["#Physics", "#Science"])
+        elif "chemistry" in title_lower:
+            hashtags.extend(["#Chemistry", "#Science"])
+
+        return hashtags[:10]

app/config/settings.py

@@ -0,0 +1,61 @@
+import os
+
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ImportError:
+    # dotenv not available, use environment variables directly
+    pass
+
+
+class Settings:
+    # LLM Configuration
+    MISTRAL_API_KEY: str = os.getenv("MISTRAL_API_KEY", "")
+
+    # Model Configuration
+    HEAVY_MODEL_PROVIDER: str = os.getenv("HEAVY_MODEL_PROVIDER", "openai")
+    HEAVY_MODEL_NAME: str = os.getenv("HEAVY_MODEL_NAME", "gpt-4-turbo")
+    HEAVY_MODEL_API_KEY: str = os.getenv("HEAVY_MODEL_API_KEY", "")
+    HEAVY_MODEL_BASE_URL: str | None = os.getenv("HEAVY_MODEL_BASE_URL")
+
+    LIGHT_MODEL_PROVIDER: str = os.getenv("LIGHT_MODEL_PROVIDER", "openai")
+    LIGHT_MODEL_NAME: str = os.getenv("LIGHT_MODEL_NAME", "gpt-3.5-turbo")
+    LIGHT_MODEL_API_KEY: str = os.getenv("LIGHT_MODEL_API_KEY", "")
+    LIGHT_MODEL_BASE_URL: str | None = os.getenv("LIGHT_MODEL_BASE_URL")
+
+    CODING_MODEL_PROVIDER: str = os.getenv("CODING_MODEL_PROVIDER", "openai")
+    CODING_MODEL_NAME: str = os.getenv("CODING_MODEL_NAME", "gpt-4-1106-preview")
+    CODING_MODEL_API_KEY: str = os.getenv("CODING_MODEL_API_KEY", "")
+    CODING_MODEL_BASE_URL: str | None = os.getenv(
+        "CODING_MODEL_BASE_URL",
+        "https://api.openai.com/v1/chat/completions",
+    )
+
+    # Image Generation
+    IMAGE_GEN_API_KEY: str = os.getenv("IMAGE_GEN_API_KEY", "")
+    IMAGE_GEN_BASE_URL: str | None = os.getenv(
+        "IMAGE_GEN_BASE_URL",
+        "https://api.openai.com/v1/images/generations",
+    )
+    IMAGE_GEN_MODEL: str = os.getenv("IMAGE_GEN_MODEL", "dall-e-3")
+    IMAGE_GEN_IMAGE_SIZE: str = os.getenv("IMAGE_GEN_IMAGE_SIZE", "1024x1024")
+    IMAGE_GEN_IMAGE_QUALITY: str = os.getenv("IMAGE_GEN_IMAGE_QUALITY", "standard")
+    IMAGE_GEN_IMAGE_STYLE: str = os.getenv("IMAGE_GEN_IMAGE_STYLE", "vivid")
+
+    # DeepInfra API for blog images
+    DEEPINFRA_API_KEY: str = os.getenv("DEEPINFRA_API_KEY", "")
+
+    # API Keys
+    DEVTO_API_KEY: str = os.getenv("DEVTO_API_KEY", "")
+
+    # Database
+    DATABASE_URL: str = os.getenv("DATABASE_URL", "sqlite:///./scholarshare.db")
+
+    # Application Settings
+    DEBUG: bool = os.getenv("DEBUG", "True").lower() == "true"
+    HOST: str = os.getenv("HOST", "0.0.0.0")
+    PORT: int = int(os.getenv("PORT", "7860"))
+
+
+settings = Settings()

app/database/database.py

@@ -0,0 +1,26 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from app.config.settings import settings
+from app.database.models import Base
+
+engine = create_engine(settings.DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def create_tables():
+    """Create all tables"""
+    Base.metadata.create_all(bind=engine)
+
+
+def get_db():
+    """Get database session"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+# Initialize database
+create_tables()

app/database/models.py

@@ -0,0 +1,48 @@
+from sqlalchemy import JSON, Boolean, Column, DateTime, Integer, String, Text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.sql import func
+
+Base = declarative_base()
+
+
+class Paper(Base):
+    __tablename__ = "papers"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String(500), nullable=False)
+    authors = Column(JSON)  # List of authors
+    abstract = Column(Text)
+    content = Column(Text)
+    source_type = Column(String(50))  # pdf, url, text
+    source_url = Column(String(500))
+    complexity_level = Column(String(50))
+    technical_terms = Column(JSON)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+
+class GeneratedContent(Base):
+    __tablename__ = "generated_content"
+
+    id = Column(Integer, primary_key=True, index=True)
+    paper_id = Column(Integer, nullable=False)
+    content_type = Column(String(50))  # blog, poster, social
+    platform = Column(String(50))  # devto, linkedin, twitter, etc.
+    title = Column(String(500))
+    content = Column(Text)
+    metadata = Column(JSON)
+    is_published = Column(Boolean, default=False)
+    published_url = Column(String(500))
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+
+class PublishingLog(Base):
+    __tablename__ = "publishing_logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    content_id = Column(Integer, nullable=False)
+    platform = Column(String(50))
+    status = Column(String(50))  # success, failed, pending
+    response_data = Column(JSON)
+    error_message = Column(Text)
+    published_at = Column(DateTime(timezone=True), server_default=func.now())

app/main.py

@@ -0,0 +1,563 @@
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+import gradio as gr
+
+from app.agents.blog_generator import BlogGeneratorAgent
+from app.agents.paper_analyzer import PaperAnalyzerAgent
+from app.agents.poster_generator import PosterGeneratorAgent
+from app.agents.tldr_generator import TLDRGeneratorAgent
+from app.config.settings import settings
+from app.models.schemas import PaperInput
+from app.services.devto_service import devto_service
+from app.services.pdf_service import pdf_service
+
+# Initialize agents
+paper_analyzer = PaperAnalyzerAgent()
+blog_generator = BlogGeneratorAgent()
+tldr_generator = TLDRGeneratorAgent()
+poster_generator = PosterGeneratorAgent()
+
+# Global state - Consider refactoring to avoid globals if possible
+current_analysis: Optional[dict] = None
+current_blog: Optional[dict] = None
+current_tldr: Optional[dict] = None
+current_poster: Optional[dict] = None
+
+
+async def process_paper(pdf_file, url_input, text_input, progress=None):
+    """Process paper from various input sources."""
+    global current_analysis
+    if progress is None:
+        progress = gr.Progress()
+
+    try:
+        progress(0.1, desc="Processing input...")
+
+        # Determine input source and extract content
+        if pdf_file is not None:
+            progress(0.2, desc="Parsing PDF...")
+            # Replaced open() with Path.open() and async read
+            pdf_path = Path(pdf_file.name)
+            pdf_content = await asyncio.to_thread(pdf_path.read_bytes)
+            # TODO: Uncomment when PDF parsing is implemented
+            # parsed_data = pdf_service.parse_pdf(pdf_content)
+            # content = parsed_data["text"]
+            # Read the PDF content directly from file parsed_pdf_content.txt
+            with open("parsed_pdf_content.txt", encoding="utf-8") as f:
+                content = f.read()
+            source_type = "pdf"
+        elif url_input and url_input.strip():
+            progress(0.2, desc="Fetching from URL...")
+            parsed_data = await pdf_service.parse_url(url_input.strip())
+            content = parsed_data["text"]
+            source_type = "url"
+        elif text_input and text_input.strip():
+            content = text_input.strip()
+            source_type = "text"
+        else:
+            return "❌ Please provide a PDF file, URL, or text input.", "", "", ""
+
+        if not content or not content.strip():
+            return "❌ No content could be extracted from the input.", "", "", ""
+
+        # Create paper input
+        paper_input = PaperInput(content=content, source_type=source_type)
+
+        # Analyze paper
+        progress(0.4, desc="Analyzing paper...")
+        current_analysis = await paper_analyzer.process(paper_input)
+        print(current_analysis)  # Debugging line
+
+        # Generate preview content
+        progress(0.7, desc="Generating previews...")
+
+        analysis_summary = f"""
+# Paper Analysis Summary
+
+## **Title:** {current_analysis.title}
+
+## **Authors:** {", ".join(current_analysis.authors)}
+
+## **Abstract:**
+{current_analysis.abstract}
+
+## **Methodology:**
+{current_analysis.methodology}
+
+## **Key Findings:**
+{chr(10).join([f"• {finding}" for finding in current_analysis.key_findings])}
+
+## **Results:**
+{current_analysis.results}
+
+## **Conclusion:**
+{current_analysis.conclusion}
+
+## **Complexity Level:** {current_analysis.complexity_level.title()}
+
+## **Technical Terms:**
+{", ".join(current_analysis.technical_terms) if current_analysis.technical_terms else "None identified"}
+        """
+
+        progress(1.0, desc="Complete!")
+
+        return (
+            "✅ Paper processed successfully!",
+            analysis_summary,
+            "Ready to generate blog content",
+            gr.DownloadButton(visible=True),
+        )
+
+    except Exception as e:
+        # Consider more specific exception handling
+        return (
+            f"❌ Error processing paper: {e!s}",
+            "",
+            "",
+            gr.DownloadButton(visible=False),
+        )
+
+
+async def generate_blog_content(progress=None):
+    """Generate blog content from analysis."""
+    global current_analysis, current_blog
+    if progress is None:
+        progress = gr.Progress()
+
+    if not current_analysis:
+        return "❌ Please process a paper first.", gr.update(
+            visible=False,
+            interactive=False,
+        )
+
+    try:
+        progress(0.1, desc="Starting blog generation...")
+        await asyncio.sleep(0.5)  # Give time for progress bar to show
+
+        progress(0.3, desc="Generating blog content...")
+        await asyncio.sleep(0.3)  # Allow UI to update
+
+        current_blog = await blog_generator.process(current_analysis)
+
+        progress(0.8, desc="Formatting blog content...")
+        await asyncio.sleep(0.3)  # Allow UI to update
+
+        blog_preview = f"""# {current_blog.title}
+
+{current_blog.content}
+
+**Tags:** {", ".join(current_blog.tags)}
+**Reading Time:** {current_blog.reading_time} minutes"""
+
+        progress(1.0, desc="Blog content generated!")
+        return blog_preview, gr.DownloadButton(visible=True)
+
+    except Exception as e:
+        # Consider more specific exception handling
+        return f"❌ Error generating blog: {e!s}", gr.DownloadButton(visible=False)
+
+
+async def generate_social_content(progress=None):
+    """Generate social media content from analysis."""
+    global current_analysis, current_tldr
+    if progress is None:
+        progress = gr.Progress()
+
+    if not current_analysis:
+        return "❌ Please process a paper first.", "", "", ""
+
+    try:
+        progress(0.3, desc="Generating social media content...")
+        current_tldr = await tldr_generator.process(current_analysis)
+
+        progress(1.0, desc="Social content generated!")
+
+        return (
+            current_tldr.linkedin_post,
+            "\n\n".join(
+                [
+                    f"Tweet {i + 1}: {tweet}"
+                    for i, tweet in enumerate(current_tldr.twitter_thread)
+                ],
+            ),
+            current_tldr.facebook_post,
+            current_tldr.instagram_caption,
+        )
+
+    except Exception as e:
+        # Consider more specific exception handling
+        error_msg = f"❌ Error generating social content: {e!s}"
+        return error_msg, error_msg, error_msg, error_msg
+
+
+async def generate_poster_content(template_type, progress=None):
+    """Generate poster content from analysis."""
+    global current_analysis, current_poster
+    if progress is None:
+        progress = gr.Progress()
+
+    if not current_analysis:
+        return "❌ Please process a paper first.", ""
+
+    try:
+        progress(0.3, desc="Generating poster...")
+        current_poster = await poster_generator.process(current_analysis, template_type)
+
+        progress(0.8, desc="Compiling LaTeX...")
+
+        poster_info = f"""
+        **Poster Generated Successfully!**
+        
+        **Template:** {template_type.upper()}
+        **PDF Path:** {current_poster.pdf_path if current_poster.pdf_path else "Compilation in progress..."}
+        
+        **LaTeX Code Preview:**
+        ```
+        {current_poster.latex_code[:300]}...
+        ```
+        """
+
+        progress(1.0, desc="Poster ready!")
+        return poster_info, current_poster.latex_code
+
+    except Exception as e:
+        # Consider more specific exception handling
+        return f"❌ Error generating poster: {e!s}", ""
+
+
+async def publish_to_devto(publish_now):
+    """Publish blog content to DEV.to."""
+    global current_blog
+
+    if not current_blog:
+        return "❌ Please generate blog content first."
+
+    try:
+        result = await devto_service.publish_article(current_blog, publish_now)
+
+        if result["success"]:
+            status = "Published" if result.get("published") else "Saved as Draft"
+            return f"✅ Article {status} successfully!\nURL: {result.get('url', 'N/A')}"
+        # Removed unnecessary else
+        return f"❌ Publication failed: {result.get('error', 'Unknown error')}"
+
+    except Exception as e:
+        # Consider more specific exception handling
+        return f"❌ Error publishing to DEV.to: {e!s}"
+
+
+def publish_draft():
+    """Sync wrapper for publishing as draft."""
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # If loop is already running, create a task
+            import concurrent.futures
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(asyncio.run, publish_to_devto(False))
+                return future.result()
+        else:
+            return loop.run_until_complete(publish_to_devto(False))
+    except RuntimeError:
+        # If no event loop, create one
+        return asyncio.run(publish_to_devto(False))
+
+
+def publish_now():
+    """Sync wrapper for publishing immediately."""
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # If loop is already running, create a task
+            import concurrent.futures
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(asyncio.run, publish_to_devto(True))
+                return future.result()
+        else:
+            return loop.run_until_complete(publish_to_devto(True))
+    except RuntimeError:
+        # If no event loop, create one
+        return asyncio.run(publish_to_devto(True))
+
+
+async def download_analysis_summary():
+    """Generate downloadable analysis summary as markdown file."""
+    global current_analysis
+
+    if not current_analysis:
+        return None
+
+    try:
+        # Create comprehensive analysis summary
+        markdown_content = f"""# Paper Analysis Summary
+
+## Title
+{current_analysis.title}
+
+## Authors
+{", ".join(current_analysis.authors)}
+
+## Abstract
+{current_analysis.abstract}
+
+## Methodology
+{current_analysis.methodology}
+
+## Key Findings
+{chr(10).join([f"- {finding}" for finding in current_analysis.key_findings])}
+
+## Results
+{current_analysis.results}
+
+## Conclusion
+{current_analysis.conclusion}
+
+## Complexity Level
+{current_analysis.complexity_level.title()}
+
+## Technical Terms
+{", ".join(current_analysis.technical_terms) if current_analysis.technical_terms else "None identified"}
+
+## Figures and Tables
+{chr(10).join([f"- {fig.get('description', 'Figure/Table')}: {fig.get('caption', 'No caption')}" for fig in current_analysis.figures_tables]) if current_analysis.figures_tables else "None identified"}
+
+---
+*Generated by ScholarShare - AI Research Dissemination Platform*
+"""
+
+        # Save to outputs directory
+        output_path = Path("outputs/analysis_summary.md")
+        output_path.write_text(markdown_content, encoding="utf-8")
+
+        return str(output_path)
+
+    except Exception:
+        return None
+
+
+async def download_blog_markdown():
+    """Generate downloadable blog content as markdown file."""
+    if not current_blog:
+        return None
+
+    try:
+        # Create comprehensive blog markdown
+        markdown_content = f"""# {current_blog.title}
+
+{current_blog.content}
+
+---
+
+**Tags:** {", ".join(current_blog.tags)}
+**Reading Time:** {current_blog.reading_time} minutes
+**Meta Description:** {current_blog.meta_description}
+
+---
+*Generated by ScholarShare - AI Research Dissemination Platform*
+"""
+
+        # Save to outputs directory
+        output_path = Path("outputs/blogs/blog_content.md")
+        output_path.write_text(markdown_content, encoding="utf-8")
+
+        return str(output_path)
+
+    except OSError:
+        return None
+
+
+# Create Gradio Interface
+def create_interface():
+    with gr.Blocks(
+        title="ScholarShare - AI Research Dissemination",
+        theme=gr.themes.Soft(),
+    ) as app:
+        gr.Markdown("""
+        # 🎓 ScholarShare - AI-Powered Research Dissemination Platform
+        
+        Transform complex research papers into accessible, multi-format content for broader audience engagement.
+        """)
+
+        with gr.Tab("📄 Paper Input & Analysis"):
+            gr.Markdown("## Upload and Analyze Research Paper")
+
+            with gr.Row():
+                with gr.Column():
+                    pdf_input = gr.File(
+                        label="Upload PDF Paper",
+                        file_types=[".pdf"],
+                        type="filepath",
+                    )
+                    url_input = gr.Textbox(
+                        label="Or Enter Paper URL (arXiv, etc.)",
+                        placeholder="https://arxiv.org/pdf/...",
+                    )
+                    text_input = gr.Textbox(
+                        label="Or Paste Paper Text",
+                        lines=5,
+                        placeholder="Paste your research paper content here...",
+                    )
+
+                    process_btn = gr.Button("🔍 Analyze Paper", variant="primary")
+
+                with gr.Column():
+                    status_output = gr.Textbox(label="Status", interactive=False)
+                    analysis_output = gr.Markdown(
+                        label="Paper Analysis",
+                        max_height=400,
+                        show_copy_button=True,
+                    )
+                    download_analysis_btn = gr.DownloadButton(
+                        label="📥 Download Analysis as Markdown",
+                        visible=False,
+                    )
+
+        with gr.Tab("📝 Blog Generation"):
+            gr.Markdown("## Generate Beginner-Friendly Blog Content")
+
+            with gr.Row():
+                with gr.Column():
+                    blog_status = gr.Textbox(label="Blog Status", interactive=False)
+                    generate_blog_btn = gr.Button(
+                        "✍️ Generate Blog Content",
+                        variant="primary",
+                    )
+                    download_blog_btn = gr.DownloadButton(
+                        label="📥 Download Blog as Markdown",
+                        visible=False,  # Changed from True to False initially
+                    )
+
+                with gr.Column():
+                    blog_output = gr.Markdown(
+                        label="Generated Blog Content",
+                        max_height=400,
+                        show_copy_button=True,
+                    )
+
+        with gr.Tab("📱 Social Media Content"):
+            gr.Markdown("## Generate Platform-Specific Social Media Content")
+
+            with gr.Row():
+                generate_social_btn = gr.Button(
+                    "📱 Generate Social Content",
+                    variant="primary",
+                )
+
+            with gr.Row():
+                with gr.Column():
+                    linkedin_output = gr.Textbox(label="LinkedIn Post", lines=5)
+                    twitter_output = gr.Textbox(label="Twitter Thread", lines=5)
+
+                with gr.Column():
+                    facebook_output = gr.Textbox(label="Facebook Post", lines=5)
+                    instagram_output = gr.Textbox(label="Instagram Caption", lines=5)
+
+        with gr.Tab("🎨 Poster Generation"):
+            gr.Markdown("## Generate Academic Conference Poster")
+
+            with gr.Row():
+                with gr.Column():
+                    template_dropdown = gr.Dropdown(
+                        choices=["ieee", "acm", "nature"],
+                        value="ieee",
+                        label="Poster Template Style",
+                    )
+                    generate_poster_btn = gr.Button(
+                        "🎨 Generate Poster",
+                        variant="primary",
+                    )
+
+                with gr.Column():
+                    poster_output = gr.Markdown(label="Poster Information")
+
+            with gr.Row():
+                latex_output = gr.Code(label="LaTeX Code", language="latex")
+
+        with gr.Tab("🚀 Publishing"):
+            gr.Markdown("## Publish Content to Platforms")
+
+            with gr.Column():
+                gr.Markdown("### DEV.to Publishing")
+                with gr.Row():
+                    publish_draft_btn = gr.Button("💾 Save as Draft")
+                    publish_now_btn = gr.Button("🚀 Publish Now", variant="primary")
+
+                publish_status = gr.Textbox(
+                    label="Publishing Status",
+                    interactive=False,
+                )
+
+        # Event handlers
+        process_btn.click(
+            fn=process_paper,
+            inputs=[pdf_input, url_input, text_input],
+            outputs=[
+                status_output,
+                analysis_output,
+                blog_status,
+                download_analysis_btn,
+            ],
+        )
+
+        download_analysis_btn.click(
+            fn=download_analysis_summary,
+            outputs=[download_analysis_btn],
+        )
+
+        generate_blog_btn.click(
+            fn=generate_blog_content,
+            outputs=[blog_output, download_blog_btn],
+        )
+
+        download_blog_btn.click(
+            fn=download_blog_markdown,
+            outputs=[download_blog_btn],
+        )
+
+        generate_social_btn.click(
+            fn=generate_social_content,
+            outputs=[
+                linkedin_output,
+                twitter_output,
+                facebook_output,
+                instagram_output,
+            ],
+        )
+
+        generate_poster_btn.click(
+            fn=generate_poster_content,
+            inputs=[template_dropdown],
+            outputs=[poster_output, latex_output],
+        )
+
+        publish_draft_btn.click(
+            fn=publish_draft,
+            outputs=[publish_status],
+        )
+
+        publish_now_btn.click(
+            fn=publish_now,
+            outputs=[publish_status],
+        )
+
+    return app
+
+
+if __name__ == "__main__":
+    # Create output directories using pathlib
+    Path("outputs/posters").mkdir(parents=True, exist_ok=True)
+    Path("outputs/blogs").mkdir(parents=True, exist_ok=True)
+    Path("data").mkdir(parents=True, exist_ok=True)
+
+    # Launch the application
+    app_instance = create_interface()
+    app_instance.launch(
+        server_name=settings.HOST,
+        server_port=settings.PORT,
+        debug=settings.DEBUG,
+        share=False,
+    )

app/models/schemas.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class PaperInput(BaseModel):
+    content: str
+    source_type: str  # "pdf", "url", "text"
+    metadata: dict[str, Any] | None = None
+
+
+class PaperAnalysis(BaseModel):
+    title: str
+    authors: list[str]
+    abstract: str
+    key_findings: list[str]
+    methodology: str
+    results: str
+    conclusion: str
+    complexity_level: str
+    technical_terms: list[str]
+    figures_tables: list[dict[str, Any]]
+
+
+class BlogContent(BaseModel):
+    title: str
+    content: str
+    tags: list[str]
+    meta_description: str
+    reading_time: int
+
+
+class TLDRContent(BaseModel):
+    linkedin_post: str
+    twitter_thread: list[str]
+    facebook_post: str
+    instagram_caption: str
+    hashtags: list[str]
+    linkedin_image: str | None = None
+    twitter_image: str | None = None
+    facebook_image: str | None = None
+    instagram_image: str | None = None
+
+
+class PosterContent(BaseModel):
+    template_type: str
+    title: str
+    authors: str
+    abstract: str
+    methodology: str
+    results: str
+    conclusion: str
+    figures: list[str]
+    latex_code: str
+    pdf_path: str | None = None
+
+
+class PublishResult(BaseModel):
+    platform: str
+    success: bool
+    url: str | None = None
+    error: str | None = None
+
+
+class SlideContent(BaseModel):
+    slide_number: int
+    title: str
+    content: str
+    slide_type: str  # "title", "content", "image", "diagram", "conclusion"
+    notes: str | None = None
+    tikz_diagrams: list[str] = []  # LaTeX tikz code for diagrams
+
+
+class TikzDiagram(BaseModel):
+    diagram_id: str
+    title: str
+    description: str
+    tikz_code: str
+    diagram_type: str  # "flowchart", "graph", "architecture", "timeline", "comparison"
+
+
+class PresentationPlan(BaseModel):
+    total_slides: int
+    slides: list[SlideContent]
+    suggested_diagrams: list[str]  # Descriptions of diagrams to create
+    presentation_style: str  # "academic", "corporate", "minimal"
+
+
+class PresentationContent(BaseModel):
+    title: str
+    authors: str
+    institution: str | None = None
+    date: str | None = None
+    template_type: str
+    slides: list[SlideContent]
+    tikz_diagrams: list[TikzDiagram]
+    latex_code: str
+    pdf_path: str | None = None
+    total_slides: int

app/services/blog_image_service.py

@@ -0,0 +1,256 @@
+import asyncio
+import base64
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import List
+
+import requests
+
+from app.models.schemas import PaperAnalysis
+
+
+class BlogImageService:
+    """Service for generating and managing images for blog posts"""
+
+    def __init__(self):
+        self.deepinfra_model = "black-forest-labs/FLUX-1-dev"
+        self.output_dir = Path("outputs/images/blog")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.upload_api_key = (
+            "6d207e02198a847aa98d0a2a901485a5"  # FreeImage.host API key
+        )
+
+    async def generate_blog_images(
+        self, analysis: PaperAnalysis, content: str
+    ) -> List[str]:
+        """Generate multiple images for a blog post and return markdown image tags"""
+        try:
+            # Generate image prompts based on the blog content
+            image_prompts = await self._generate_image_prompts(analysis, content)
+
+            # Generate images using DeepInfra
+            image_urls = await self._generate_images_async(image_prompts)
+
+            # Create markdown image tags with proper formatting
+            markdown_images = []
+            for i, url in enumerate(image_urls):
+                if url and url != "No image URL found":
+                    caption = self._generate_image_caption(analysis, i)
+                    markdown_images.append(f"![{caption}]({url})")
+
+            return markdown_images
+
+        except Exception as e:
+            print(f"Error generating blog images: {e}")
+            return []
+
+    async def _generate_image_prompts(
+        self, analysis: PaperAnalysis, content: str
+    ) -> List[str]:
+        """Generate image prompts based on the research paper and blog content"""
+        from app.services.llm_service import LLMService
+
+        llm_service = LLMService()
+
+        prompt_generation_text = f"""
+        You are an expert in creating visual prompts for AI image generation to enhance blog posts about research papers.
+        
+        Research Paper Details:
+        Title: {analysis.title}
+        Abstract: {analysis.abstract[:300]}...
+        Key Findings: {", ".join(analysis.key_findings[:3])}
+        Methodology: {analysis.methodology[:200]}...
+        
+        Blog Content Preview: {content[:500]}...
+        
+        Create 2-3 detailed visual prompts for FLUX image generation that would enhance this blog post. 
+        Each prompt should:
+        1. Be scientifically accurate and relevant to the research
+        2. Create visually appealing, professional diagrams or illustrations
+        3. Help explain complex concepts through visual metaphors
+        4. Be suitable for a blog audience (clear, engaging, informative)
+        
+        Generate prompts for:
+        1. A main concept illustration (abstract/conceptual)
+        2. A methodology visualization (process/workflow)
+        3. A results/findings/use-case illustration (if applicable)
+
+        Each prompt should be highly detailed, incorporating the elements that needed along with the details like colors, style, textures, background details, and also mention the correct position of the elements in the image.
+
+        Return only the prompts, one per line, without numbering or additional text.
+        """
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are an expert visual designer specializing in scientific and educational imagery for blog posts.",
+            },
+            {"role": "user", "content": prompt_generation_text},
+        ]
+
+        response = await llm_service.generate_completion(
+            messages=messages,
+            model_type="light",
+            temperature=0.7,
+        )
+
+        # Parse the response to extract individual prompts
+        prompts = [prompt.strip() for prompt in response.split("\n") if prompt.strip()]
+
+        # Enhance prompts with style guidelines
+        enhanced_prompts = []
+        for prompt in prompts[:3]:  # Limit to 3 images
+            enhanced_prompt = f"{prompt}, professional scientific illustration, clean modern design, educational diagram style, high quality, detailed"
+            enhanced_prompts.append(enhanced_prompt)
+
+        return enhanced_prompts
+
+    async def _generate_images_async(self, prompts: List[str]) -> List[str]:
+        """Generate images asynchronously using DeepInfra API"""
+        loop = asyncio.get_event_loop()
+
+        # Use ThreadPoolExecutor to handle blocking requests
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = [
+                loop.run_in_executor(executor, self._fetch_image_url, prompt)
+                for prompt in prompts
+            ]
+
+            results = await asyncio.gather(*futures, return_exceptions=True)
+
+            # Process results and upload images
+            upload_futures = []
+            for result in results:
+                if isinstance(result, str) and result != "No image URL found":
+                    upload_futures.append(
+                        loop.run_in_executor(
+                            executor, self._process_and_upload_image, result
+                        ),
+                    )
+
+            if upload_futures:
+                uploaded_urls = await asyncio.gather(
+                    *upload_futures, return_exceptions=True
+                )
+                return [
+                    url if not isinstance(url, Exception) else "No image URL found"
+                    for url in uploaded_urls
+                ]
+
+            return []
+
+    def _fetch_image_url(self, prompt: str) -> str:
+        """Fetch image from DeepInfra API (synchronous)"""
+        url = f"https://api.deepinfra.com/v1/inference/{self.deepinfra_model}"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"bearer {os.getenv('DEEPINFRA_API_KEY')}",
+        }
+        payload = {
+            "prompt": prompt,
+            "num_inference_steps": 20,
+            "width": 1024,
+            "height": 768,  # Better aspect ratio for blog images
+        }
+
+        try:
+            response = requests.post(url, json=payload, headers=headers, timeout=60)
+            if response.status_code == 200:
+                response_data = response.json()
+                images = response_data.get("images", [])
+                return images[0] if images else "No image URL found"
+            print(f"Request failed: {response.status_code}, {response.text}")
+            return "No image URL found"
+        except Exception as e:
+            print(f"An error occurred: {e!s}")
+            return "No image URL found"
+
+    def _process_and_upload_image(self, base64_string: str) -> str:
+        """Process base64 image and upload to hosting service (synchronous)"""
+        try:
+            # Save image locally first
+            image_data = base64.b64decode(base64_string.split(",")[-1])
+            temp_filename = f"temp_blog_image_{hash(base64_string) % 1000000}.png"
+            temp_path = self.output_dir / temp_filename
+
+            with open(temp_path, "wb") as image_file:
+                image_file.write(image_data)
+
+            # Upload to hosting service
+            url = "https://freeimage.host/api/1/upload"
+
+            with open(temp_path, "rb") as image_file:
+                base64_image = base64.b64encode(image_file.read()).decode("utf-8")
+
+            payload = {
+                "key": self.upload_api_key,
+                "action": "upload",
+                "source": base64_image,
+                "format": "json",
+            }
+
+            response = requests.post(url, data=payload, timeout=60)
+
+            if response.status_code == 200:
+                response_data = response.json()
+                hosted_url = response_data.get("image", {}).get(
+                    "url", "No image URL found"
+                )
+
+                # Clean up temp file
+                try:
+                    temp_path.unlink()
+                except:
+                    pass
+
+                return hosted_url
+            print(f"Upload failed: {response.status_code}, {response.text}")
+            return "No image URL found"
+
+        except Exception as e:
+            print(f"Error processing/uploading image: {e!s}")
+            return "No image URL found"
+
+    def _generate_image_caption(self, analysis: PaperAnalysis, image_index: int) -> str:
+        """Generate appropriate captions for images"""
+        captions = [
+            f"Conceptual illustration of {analysis.title[:50]}...",
+            f"Methodology visualization for {analysis.title[:50]}...",
+            f"Key findings illustration from {analysis.title[:50]}...",
+        ]
+
+        if image_index < len(captions):
+            return captions[image_index]
+        return f"Research illustration from {analysis.title[:50]}..."
+
+    async def embed_images_in_content(self, content: str, images: List[str]) -> str:
+        """Embed images into blog content at appropriate locations"""
+        if not images:
+            return content
+
+        # Split content into sections (by headers)
+        sections = re.split(r"(^#{1,3}\s+.*$)", content, flags=re.MULTILINE)
+
+        # Insert images at strategic points
+        enhanced_content = []
+        image_index = 0
+
+        for i, section in enumerate(sections):
+            enhanced_content.append(section)
+
+            # Add image after introduction (first section after first header)
+            if (
+                (i == 2 and image_index < len(images))
+                or (i == len(sections) // 2 and image_index < len(images))
+                or (i == len(sections) - 3 and image_index < len(images))
+            ):
+                enhanced_content.append(f"\n\n{images[image_index]}\n\n")
+                image_index += 1
+
+        return "".join(enhanced_content)
+
+
+# Global instance
+blog_image_service = BlogImageService()

app/services/devto_service.py

@@ -0,0 +1,133 @@
+import asyncio
+from typing import Any, Dict
+
+import requests
+
+from app.config.settings import settings
+from app.models.schemas import BlogContent
+
+
+class DevToService:
+    def __init__(self):
+        self.api_key = settings.DEVTO_API_KEY
+        self.base_url = "https://dev.to/api"
+
+    async def publish_article(
+        self,
+        blog_content: BlogContent,
+        publish_now: bool = False,
+    ) -> Dict[str, Any]:
+        """Publish article to DEV.to"""
+
+        def _sync_publish():
+            try:
+                # Check if API key is configured
+                if not self.api_key:
+                    return {
+                        "success": False,
+                        "error": "DEV.to API key is not configured. Please set the DEVTO_API_KEY environment variable.",
+                    }
+
+                headers = {
+                    "api-key": self.api_key,
+                    "Content-Type": "application/json",
+                }
+
+                # Ensure tags is a list of strings
+                tags = blog_content.tags if isinstance(blog_content.tags, list) else []
+                # DEV.to has a limit of 4 tags max
+                tags = tags[:4] if len(tags) > 4 else tags
+
+                article_data = {
+                    "article": {
+                        "title": blog_content.title,
+                        "body_markdown": blog_content.content,
+                        "published": publish_now,
+                        "tags": tags,
+                        "description": blog_content.meta_description,
+                    },
+                }
+
+                # Only add series if it's not empty
+                if hasattr(blog_content, "series") and blog_content.series:
+                    article_data["article"]["series"] = blog_content.series
+
+                print("=== DEV.to Publish Debug Info ===")
+                print(f"API Key present: {bool(self.api_key)}")
+                print(f"API Key length: {len(self.api_key) if self.api_key else 0}")
+                print(f"Title: {blog_content.title}")
+                print(f"Tags: {tags}")
+                print(f"Content length: {len(blog_content.content)}")
+                print(f"Description: {blog_content.meta_description}")
+                print("Article data structure:")
+                print(article_data)
+
+                response = requests.post(
+                    f"{self.base_url}/articles",
+                    json=article_data,
+                    headers=headers,
+                    timeout=30,  # Add timeout
+                )
+                response.raise_for_status()
+                result = response.json()
+
+                return {
+                    "success": True,
+                    "url": result.get("url"),
+                    "id": result.get("id"),
+                    "published": result.get("published", False),
+                }
+
+            except requests.exceptions.HTTPError as e:
+                # Get the detailed error response from DEV.to
+                error_details = "Unknown error"
+                if hasattr(e, "response") and e.response is not None:
+                    try:
+                        error_details = e.response.json()
+                    except:
+                        error_details = e.response.text
+
+                print(f"DEV.to API Error: {e}")
+                print(f"Error details: {error_details}")
+
+                return {
+                    "success": False,
+                    "error": f"DEV.to API Error: {e!s} - Details: {error_details}",
+                }
+            except Exception as e:
+                print(f"General error: {e}")
+                return {
+                    "success": False,
+                    "error": str(e),
+                }
+
+        # Run the synchronous function in a thread pool
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, _sync_publish)
+
+    async def get_my_articles(self, per_page: int = 10) -> Dict[str, Any]:
+        """Get user's published articles"""
+
+        def _sync_get_articles():
+            try:
+                headers = {
+                    "api-key": self.api_key,
+                }
+
+                response = requests.get(
+                    f"{self.base_url}/articles/me/published?per_page={per_page}",
+                    headers=headers,
+                    timeout=30,  # Add timeout
+                )
+                response.raise_for_status()
+                result = response.json()
+                return {"success": True, "articles": result}
+            except Exception as e:
+                return {"success": False, "error": str(e)}
+
+        # Run the synchronous function in a thread pool
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, _sync_get_articles)
+
+
+devto_service = DevToService()