initial commit

.dockerignore

@@ -0,0 +1,11 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+env/
+venv/
+*.log
+.git
+.gitignore
+tests/
+.DS_Store

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.env

Dockerfile

@@ -1,21 +1,27 @@
-FROM python:3.9-slim
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
+RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
-    curl \
-    software-properties-common \
-    git \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+COPY requirements.txt .
+
+RUN pip install --upgrade pip && pip install -r requirements.txt
 
-RUN pip3 install -r requirements.txt
+COPY . .
 
-EXPOSE 8501
+ENV PORT=7860
+ENV STREAMLIT_SERVER_PORT=$PORT
+ENV STREAMLIT_SERVER_HEADLESS=true
+ENV STREAMLIT_SERVER_ENABLECORS=false
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+EXPOSE 7860
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "app.py", "--server.port", "7860", "--server.headless", "true", "--server.address", "0.0.0.0"]

README.md

@@ -1,19 +1,419 @@
----
-title: LinkedIn Post Generator
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
+# 🚀 LangGraph Post Generator
+
+An intelligent LinkedIn post generator powered by **LangGraph** and **Azure OpenAI** that creates engaging, professional content by intelligently routing queries through web search and content generation workflows.
+
+## 📋 Table of Contents
+
+- [Overview](#overview)
+- [Features](#features)
+- [Architecture](#architecture)
+- [Tech Stack](#tech-stack)
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Usage](#usage)
+- [Project Structure](#project-structure)
+- [API Documentation](#api-documentation)
+- [Technical Details](#technical-details)
+- [Testing](#testing)
+- [Contributing](#contributing)
+- [License](#license)
+
+## 🌟 Overview
+
+The **LangGraph Post Generator** is an AI-powered application that transforms simple topic inputs into compelling LinkedIn posts. It leverages the power of **LangGraph** to create an intelligent workflow that decides whether to search for additional context or directly generate content based on the input query.
+
+### Key Capabilities:
+- **Intelligent Routing**: Automatically determines if web search is needed for better context
+- **Web Search Integration**: Uses DuckDuckGo to gather recent, relevant information
+- **Professional Content Generation**: Creates LinkedIn-optimized posts with proper tone and structure
+- **Real-time Processing**: Streamlit-based web interface for immediate results
+- **Comprehensive Logging**: Detailed logging for debugging and monitoring
+
+## ✨ Features
+
+- 🧠 **Smart Query Routing**: AI-powered decision making for content enhancement
+- 🔍 **Real-time Web Search**: Integration with DuckDuckGo for up-to-date information
+- 📝 **Professional Content Creation**: LinkedIn-optimized posts with engaging tone
+- 🎯 **Context-Aware Generation**: Uses web search results to create informed content
+- 📊 **Enhanced Streamlit Interface**: Beautiful, modern UI with sidebar configurations
+- ⚙️ **Configurable Settings**: Customize post length, tone, hashtags, and call-to-action
+- 🎨 **Professional Styling**: LinkedIn-inspired design with gradients and modern components
+- 📈 **Post Analytics**: Track generated posts and usage statistics
+- 💡 **Smart Suggestions**: Hashtag recommendations and example topics
+- 🔧 **Modular Architecture**: Clean, maintainable codebase with separation of concerns
+- 📋 **Comprehensive Logging**: Detailed logs for monitoring and debugging
+- 🔄 **Flexible Workflow**: LangGraph-powered state management
+
+## 🏗️ Architecture
+
+The application follows a **LangGraph-based workflow** with the following components:
+
+```mermaid
+graph TD
+    A[User Input] --> B[Question Router]
+    B --> C{Route Decision}
+    C -->|Need Context| D[Query Transform]
+    C -->|Direct Generation| E[Content Generator]
+    D --> F[Web Search]
+    F --> E
+    E --> G[LinkedIn Post Output]
+```
+
+### Workflow Steps:
+1. **Input Processing**: User provides a topic through Streamlit interface
+2. **Question Routing**: AI determines if web search is needed
+3. **Query Transformation** (if needed): Optimizes the query for web search
+4. **Web Search** (if needed): Gathers relevant context using DuckDuckGo
+5. **Content Generation**: Creates professional LinkedIn post using Azure OpenAI
+6. **Output**: Returns formatted LinkedIn post to user
+
+## 🛠️ Tech Stack
+
+### Core Technologies:
+- **Python 3.8+** - Primary programming language
+- **LangGraph** - Workflow orchestration and state management
+- **LangChain** - LLM framework and prompt management
+- **Azure OpenAI** - Language model for content generation
+- **Streamlit** - Web application framework
+- **DuckDuckGo Search** - Web search functionality
+
+### Dependencies:
+- `streamlit` - Web interface
+- `langchain` - LLM framework
+- `langchain-core` - Core LangChain functionality
+- `langchain-community` - Community tools and utilities
+- `langchain-openai` - Azure OpenAI integration
+- `langgraph` - Graph-based workflow management
+- `langsmith` - LangChain monitoring and debugging
+- `duckduckgo-search` - Web search capabilities
+- `python-dotenv` - Environment variable management
+
+## 📦 Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- Azure OpenAI API access
+- Git (for cloning the repository)
+
+### Step 1: Clone the Repository
+```bash
+git clone https://github.com/your-username/langgraph-post-generator.git
+cd langgraph-post-generator/post-generator-agent
+```
+
+### Step 2: Create Virtual Environment
+```bash
+# Create virtual environment
+python -m venv venv
+
+# Activate virtual environment
+# On Windows:
+venv\Scripts\activate
+# On macOS/Linux:
+source venv/bin/activate
+```
+
+### Step 3: Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### Step 4: Run the Application
+```bash
+streamlit run app.py
+```
+
+### Step 5: Configure Credentials
+1. Open the app in your browser
+2. Go to the sidebar configuration
+3. Enter your Azure OpenAI credentials:
+   - **API Key**: Your Azure OpenAI API key
+   - **Endpoint**: Your Azure OpenAI endpoint (e.g., `https://your-resource.openai.azure.com/`)
+   - **Deployment Name**: Your model deployment name (e.g., `gpt-35-turbo`)
+   - **API Version**: API version (default: `2024-02-01`)
+4. Click "Save Credentials"
+5. Test the connection using the "Test Connection" button
+
+## ⚙️ Configuration
+
+### Azure OpenAI Setup
+
+1. **Create Azure OpenAI Resource**:
+   - Go to [Azure Portal](https://portal.azure.com)
+   - Create a new OpenAI resource
+   - Note your endpoint and API key
+
+2. **Deploy a Model**:
+   - Deploy a GPT model (GPT-3.5-turbo or GPT-4)
+   - Note your deployment name
+
+3. **Update Configuration**:
+   - Add your credentials to the `.env` file
+   - Ensure the API version matches your Azure OpenAI service
+
+### Environment Variables
+
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `AZURE_OPENAI_API_KEY` | Your Azure OpenAI API key | `abc123...` |
+| `AZURE_OPENAI_ENDPOINT` | Your Azure OpenAI endpoint URL | `https://example.openai.azure.com/` |
+| `OPENAI_API_VERSION` | API version for Azure OpenAI | `2024-02-01` |
+| `AZURE_DEPLOYMENT` | Name of your model deployment | `gpt-35-turbo` |
+
+## 🚀 Usage
+
+### Running the Application
+
+1. **Start the Streamlit App**:
+```bash
+streamlit run app.py
+```
+
+2. **Access the Interface**:
+   - Open your browser to `http://localhost:8501`
+   - Configure settings in the sidebar (post length, tone, hashtags)
+   - Enter a topic in the main input area
+   - Add optional context for better results
+   - Click "Generate LinkedIn Post" to create content
+   - View the generated post in a styled container
+   - Use example topics for quick testing
+
+### UI Features
+
+- **📊 Sidebar Configuration**: 
+  - **🔑 Azure Credentials Management**: 
+    - Manual credential input with password masking
+    - Real-time credential validation for Azure OpenAI format
+    - Connection testing functionality
+    - Credential persistence across sessions
+  - API status indicators with masked API keys
+  - Post length options (Short, Medium, Long)
+  - Tone selection (Professional, Casual, Enthusiastic, etc.)
+  - Hashtag and call-to-action toggles
+  - Hashtag suggestions based on topic
+
+- **🎯 Main Interface**:
+  - Large text area for topic input
+  - Optional context expander
+  - Generate and Clear buttons
+  - Tips for better posts
+  - Post analytics tracking
+  - Example topics for quick testing
+
+- **📄 Output Display**:
+  - Styled output container
+  - Success/error messages
+  - Copy to clipboard functionality
+
+### Example Usage
+
+**Input**: "Artificial Intelligence trends in 2024"
+
+**Output**: A professionally formatted LinkedIn post including:
+- Current AI trends and insights
+- Professional tone suitable for LinkedIn
+- Actionable insights for professionals
+- Engaging call-to-action or discussion points
+
+### Command Line Testing
+
+You can also test individual components:
+
+```bash
+# Test LLM configuration
+python tests/llm_test.py
+
+# Test web search functionality
+python tests/search_test.py
+
+# Test the complete agent workflow
+python utils/run_agent.py
+```
+
+## 📁 Project Structure
+
+```
+post-generator-agent/
+├── 📄 app.py                     # Main Streamlit application
+├── 📁 config/
+│   ├── configs.py                # Environment configuration
+│   └── generation_config.py      # Generation settings and prompts
+├── 📁 helper/
+│   ├── configure_llm.py          # Azure OpenAI LLM setup
+│   ├── graphs.py                 # LangGraph workflow definition
+│   ├── model_load.py             # Graph state model
+│   └── web_search_agent.py       # DuckDuckGo search configuration
+├── 📁 loggers/
+│   └── logger.py                 # Logging configuration
+├── 📁 template/
+│   ├── response_prompt.py        # Content generation prompts
+│   ├── router_prompt.py          # Query routing prompts
+│   └── transform_prompt.py       # Query transformation prompts
+├── 📁 tests/
+│   ├── llm_test.py              # LLM functionality tests
+│   └── search_test.py           # Search functionality tests
+├── 📁 utils/
+│   ├── credential_manager.py     # Azure credentials management
+│   ├── generate_content.py       # Content generation logic
+│   ├── query_transform.py        # Query transformation logic
+│   ├── question_route.py         # Question routing logic
+│   ├── run_agent.py             # Main agent execution
+│   └── search_web_content.py     # Web search implementation
+├── 📄 requirements.txt           # Python dependencies
+└── 📄 README.md                 # This documentation
+```
 
-# Welcome to Streamlit!
+## 📖 API Documentation
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+### Core Functions
+
+#### `execute_agent(query: str) -> str`
+Main function to execute the LangGraph workflow.
+
+**Parameters:**
+- `query` (str): The topic or question for LinkedIn post generation
+
+**Returns:**
+- `str`: Generated LinkedIn post content
+
+**Example:**
+```python
+from utils.run_agent import execute_agent
+
+result = execute_agent("Latest trends in machine learning")
+print(result)
+```
+
+#### `route_question(state: dict) -> str`
+Routes questions to appropriate workflow paths.
+
+**Parameters:**
+- `state` (dict): Current graph state containing the question
+
+**Returns:**
+- `str`: Routing decision ("websearch" or "generate")
+
+#### `transform_query(state: dict) -> dict`
+Transforms user queries for optimal web search.
+
+**Parameters:**
+- `state` (dict): Current graph state
+
+**Returns:**
+- `dict`: Updated state with optimized search query
+
+#### `web_search(state: dict) -> dict`
+Performs web search using DuckDuckGo.
+
+**Parameters:**
+- `state` (dict): Current graph state with search query
+
+**Returns:**
+- `dict`: Updated state with search results context
+
+#### `generate(state: dict) -> dict`
+Generates final LinkedIn post content.
+
+**Parameters:**
+- `state` (dict): Current graph state with question and optional context
+
+**Returns:**
+- `dict`: Updated state with generated content
+
+## 🔧 Technical Details
+
+### LangGraph Workflow
+
+The application uses **LangGraph** to create a stateful workflow:
+
+```python
+# Graph state definition
+class GraphState(TypedDict):
+    question: str      # Original user question
+    generation: str    # Generated LinkedIn post
+    search_query: str  # Optimized search query
+    context: str       # Web search results
+```
+
+### Prompt Engineering
+
+The system uses three specialized prompt templates:
+
+1. **Router Prompt**: Determines routing strategy
+2. **Transform Prompt**: Optimizes queries for web search
+3. **Response Prompt**: Generates LinkedIn-optimized content
+
+### Logging System
+
+Comprehensive logging with:
+- **File Logging**: Timestamped log files in `logs/` directory
+- **Console Logging**: Real-time feedback during execution
+- **Multiple Log Levels**: DEBUG, INFO, WARNING, ERROR
+
+### Error Handling
+
+Robust error handling including:
+- Graceful fallbacks when web search fails
+- Retry mechanisms for API calls
+- Comprehensive error logging
+
+## 🧪 Testing
+
+### Running Tests
+
+```bash
+# Test Azure OpenAI connection
+python tests/llm_test.py
+
+# Test web search functionality
+python tests/search_test.py
+
+# Test complete workflow
+python utils/run_agent.py
+```
+
+### Test Coverage
+
+- **LLM Integration**: Validates Azure OpenAI connectivity
+- **Web Search**: Tests DuckDuckGo search functionality
+- **End-to-End**: Complete workflow validation
+
+## 🤝 Contributing
+
+We welcome contributions! Please follow these steps:
+
+1. **Fork the Repository**
+2. **Create Feature Branch**: `git checkout -b feature/amazing-feature`
+3. **Commit Changes**: `git commit -m 'Add amazing feature'`
+4. **Push to Branch**: `git push origin feature/amazing-feature`
+5. **Open Pull Request**
+
+### Development Guidelines
+
+- Follow PEP 8 style guidelines
+- Add comprehensive docstrings
+- Include tests for new features
+- Update documentation as needed
+
+## 📄 License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.
+
+## 🆘 Support
+
+For support and questions:
+
+- **Issues**: Open an issue on GitHub
+- **Documentation**: Check this README and code comments
+- **Community**: Join our discussions
+
+## 🙏 Acknowledgments
+
+- **LangChain Team** for the excellent LLM framework
+- **Azure OpenAI** for powerful language models
+- **Streamlit** for the intuitive web framework
+- **DuckDuckGo** for search capabilities
+
+---
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+**Built with ❤️ using LangGraph and Azure OpenAI**

app.py

@@ -0,0 +1,346 @@
+import streamlit as st
+import time
+import os
+from utils.run_agent import execute_agent
+from config.configs import AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, AZURE_DEPLOYMENT
+from config.generation_config import get_generation_prompt, get_hashtag_suggestions, DEFAULT_SETTINGS
+from utils.credential_manager import CredentialManager, format_endpoint_url, mask_api_key
+
+st.set_page_config(
+    page_title="LinkedIn Post Generator",
+    page_icon="📝",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #0077B5, #00A0DC);
+        padding: 2rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    
+    .sidebar-header {
+        background: linear-gradient(135deg, #f8f9fa, #e9ecef);
+        padding: 1rem;
+        border-radius: 8px;
+        margin-bottom: 1rem;
+    }
+    
+    .config-section {
+        background: #f8f9fa;
+        padding: 1rem;
+        border-radius: 8px;
+        margin-bottom: 1rem;
+        border-left: 4px solid #0077B5;
+    }
+    
+    .output-container {
+        background: #f8f9fa;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border: 1px solid #dee2e6;
+        margin-top: 1rem;
+    }
+    
+    .loading-spinner {
+        text-align: center;
+        padding: 2rem;
+    }
+    
+    .success-message {
+        background: #d4edda;
+        color: #155724;
+        padding: 1rem;
+        border-radius: 8px;
+        border: 1px solid #c3e6cb;
+        margin: 1rem 0;
+    }
+    
+    .error-message {
+        background: #f8d7da;
+        color: #721c24;
+        padding: 1rem;
+        border-radius: 8px;
+        border: 1px solid #f5c6cb;
+        margin: 1rem 0;
+    }
+    
+    .credentials-section {
+        background: #fff3cd;
+        padding: 1rem;
+        border-radius: 8px;
+        border: 1px solid #ffeaa7;
+        margin-bottom: 1rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state for credentials
+if 'azure_api_key' not in st.session_state:
+    st.session_state.azure_api_key = ""
+if 'azure_endpoint' not in st.session_state:
+    st.session_state.azure_endpoint = ""
+if 'azure_deployment' not in st.session_state:
+    st.session_state.azure_deployment = ""
+if 'azure_api_version' not in st.session_state:
+    st.session_state.azure_api_version = "2024-02-01"
+
+with st.sidebar:
+    st.title("⚙️ Configuration")
+
+    st.subheader("🔑 Azure OpenAI Credentials")
+    
+    st.info("💡 Enter your Azure OpenAI credentials below:")
+    
+    api_key = st.text_input(
+        "Azure OpenAI API Key",
+        value=st.session_state.azure_api_key,
+        type="password",
+        help="Your Azure OpenAI API key"
+    )
+    
+    endpoint = st.text_input(
+        "Azure OpenAI Endpoint",
+        value=st.session_state.azure_endpoint,
+        placeholder="https://your-resource.openai.azure.com/",
+        help="Your Azure OpenAI endpoint URL"
+    )
+    
+    deployment = st.text_input(
+        "Deployment Name",
+        value=st.session_state.azure_deployment,
+        placeholder="gpt-35-turbo",
+        help="Name of your deployed model"
+    )
+    
+    api_version = st.text_input(
+        "API Version",
+        value=st.session_state.azure_api_version,
+        placeholder="2024-02-01",
+        help="Azure OpenAI API version"
+    )
+    
+    if st.button("💾 Save Credentials", use_container_width=True):
+        credentials = {
+            'api_key': api_key,
+            'endpoint': format_endpoint_url(endpoint) if endpoint else '',
+            'deployment': deployment,
+            'api_version': api_version
+        }
+        
+        is_valid, message = CredentialManager.validate_credentials(credentials)
+        
+        if is_valid:
+            CredentialManager.save_credentials_to_session(
+                credentials['api_key'],
+                credentials['endpoint'],
+                credentials['deployment'],
+                credentials['api_version']
+            )
+            st.success("✅ Credentials saved successfully!")
+            st.rerun()
+        else:
+            st.error(f"❌ {message}")
+    
+    if st.button("🗑️ Clear Credentials", use_container_width=True):
+        CredentialManager.clear_session_credentials()
+        st.success("✅ Credentials cleared!")
+        st.rerun()
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+    
+    st.subheader("🔍 API Status")
+    
+    current_credentials = CredentialManager.get_credentials_from_session()
+    
+    if current_credentials['api_key']:
+        masked_key = mask_api_key(current_credentials['api_key'])
+        st.success(f"✅ API Key: {masked_key}")
+    else:
+        st.error("❌ API Key not found")
+    
+    if current_credentials['endpoint']:
+        st.success(f"✅ Endpoint: {current_credentials['endpoint']}")
+    else:
+        st.warning("⚠️ Endpoint not configured")
+    
+    if current_credentials['deployment']:
+        st.success(f"✅ Deployment: {current_credentials['deployment']}")
+    else:
+        st.warning("⚠️ Deployment not configured")
+    
+    if all(current_credentials.values()):
+        if st.button("🧪 Test Connection", use_container_width=True):
+            with st.spinner("Testing Azure OpenAI connection..."):
+                try:
+                    CredentialManager.set_environment_variables(current_credentials)
+                    
+                    test_output = execute_agent("Test connection")
+                    st.success("✅ Connection successful! Azure OpenAI is working.")
+                except Exception as e:
+                    st.error(f"❌ Connection failed: {str(e)}")
+    
+    st.subheader("🎯 Generation Settings")
+    
+    post_length = st.selectbox(
+        "Post Length",
+        ["Short (100-200 words)", "Medium (200-400 words)", "Long (400-600 words)"],
+        index=1
+    )
+    
+    tone = st.selectbox(
+        "Tone",
+        ["Professional", "Casual", "Enthusiastic", "Educational", "Inspirational"],
+        index=0
+    )
+    
+    include_hashtags = st.checkbox("Include Hashtags", value=True)
+    include_call_to_action = st.checkbox("Include Call to Action", value=True)
+    
+    st.subheader("ℹ️ About")
+    st.write("**LinkedIn Post Generator**")
+    st.write("Powered by LangGraph and Azure OpenAI")
+    st.write("Version: 1.0.0")
+
+st.title("📝 LinkedIn Post Generator")
+st.markdown("Transform your ideas into engaging LinkedIn posts using AI")
+
+col1, col2 = st.columns([2, 1])
+
+with col1:
+    st.subheader("🎯 What would you like to write about?")
+    
+    user_input = st.text_area(
+        "Enter your topic, idea, or subject matter:",
+        value=st.session_state.get("user_input", ""),
+        placeholder="e.g., 'The future of artificial intelligence in healthcare' or 'Tips for remote team collaboration'",
+        height=100,
+        help="Be specific about your topic to get better results"
+    )
+    
+    if user_input and include_hashtags:
+        suggested_hashtags = get_hashtag_suggestions(user_input)
+        st.info(f"💡 **Suggested hashtags for '{user_input}':**")
+        hashtag_cols = st.columns(3)
+        for i, hashtag in enumerate(suggested_hashtags[:3]):
+            with hashtag_cols[i]:
+                st.write(f"• {hashtag}")
+    
+    with st.expander("🔍 Additional Context (Optional)"):
+        context = st.text_area(
+            "Add any specific details, target audience, or context:",
+            placeholder="e.g., 'Target audience: Tech professionals, Focus on practical applications'",
+            height=80
+        )
+    
+    col1_btn, col2_btn = st.columns([3, 1])
+    
+    with col1_btn:
+        generate_clicked = st.button("🚀 Generate LinkedIn Post", type="primary", use_container_width=True)
+    
+    with col2_btn:
+        clear_clicked = st.button("🗑️ Clear", use_container_width=True)
+    
+    if clear_clicked:
+        st.session_state.user_input = ""
+        st.session_state.example_topic = ""
+        st.rerun()
+    
+    if generate_clicked:
+        if user_input:
+            current_credentials = CredentialManager.get_credentials_from_session()
+            
+            if not all(current_credentials.values()):
+                st.error("❌ Please configure your Azure OpenAI credentials in the sidebar first.")
+            else:
+                CredentialManager.set_environment_variables(current_credentials)
+                
+                with st.spinner("🤖 AI is crafting your perfect LinkedIn post..."):
+                    try:
+                        settings = {
+                            "post_length": post_length,
+                            "tone": tone,
+                            "include_hashtags": include_hashtags,
+                            "include_call_to_action": include_call_to_action
+                        }
+                        
+                        # Generate formatted prompt using the configuration
+                        full_query = get_generation_prompt(user_input, context, settings)
+                        
+                        # Execute the agent
+                        output = execute_agent(full_query)
+                        
+                        # Update session state
+                        if 'generated_posts' not in st.session_state:
+                            st.session_state.generated_posts = 0
+                        st.session_state.generated_posts += 1
+                        
+                        st.success("✅ Your LinkedIn post has been generated successfully!")                    
+
+                        st.subheader("📄 Generated LinkedIn Post")
+                        st.markdown("---")
+                        st.write(output)
+                        st.markdown("---")
+                        
+                        if st.button("📋 Copy to Clipboard", use_container_width=True):
+                            st.write("📋 Post copied to clipboard!")
+                            
+                    except Exception as e:
+                        st.error(f"❌ An error occurred: {str(e)}")
+        else:
+            st.warning("⚠️ Please enter a topic to generate a post.")
+
+with col2:
+    st.subheader("💡 Tips for Better Posts")
+    
+    tips = [
+        "🎯 Be specific about your topic",
+        "👥 Consider your target audience",
+        "📊 Include relevant statistics if applicable",
+        "💬 Ask engaging questions",
+        "🔗 Reference current trends or news",
+        "📝 Keep paragraphs short and readable",
+        "🎨 Use emojis sparingly but effectively"
+    ]
+    
+    for tip in tips:
+        st.write(tip)
+    
+    st.markdown("---")
+    
+    st.subheader("📈 Post Analytics")
+    if 'generated_posts' not in st.session_state:
+        st.session_state.generated_posts = 0
+    
+    st.metric("Posts Generated", st.session_state.generated_posts)
+
+    st.subheader("🎯 Example Topics")
+    example_topics = [
+        "AI in healthcare",
+        "Remote work productivity",
+        "Digital transformation",
+        "Leadership skills",
+        "Innovation in business"
+    ]
+    
+    for topic in example_topics:
+        if st.button(topic, key=f"example_{topic}"):
+            st.session_state.example_topic = topic
+            st.session_state.user_input = topic
+            st.rerun()
+
+st.markdown("---")
+st.markdown(
+    """
+    <div style='text-align: center; color: #666; padding: 1rem;'>
+        <p>Made with ❤️ using Streamlit, LangGraph, and Azure OpenAI</p>
+        <p>For questions or support, please check the documentation</p>
+    </div>
+    """,
+    unsafe_allow_html=True
+)

config/configs.py

@@ -0,0 +1,15 @@
+import sys
+sys.dont_write_bytecode = True
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+AZURE_OPENAI_API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
+
+OPENAI_API_VERSION = os.getenv("OPENAI_API_VERSION")
+
+AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
+
+AZURE_DEPLOYMENT = os.getenv("AZURE_DEPLOYMENT")

config/generation_config.py

@@ -0,0 +1,90 @@
+"""
+Generation configuration settings for the LinkedIn Post Generator
+"""
+
+# Post length configurations
+POST_LENGTHS = {
+    "Short (100-200 words)": {"min_words": 100, "max_words": 200},
+    "Medium (200-400 words)": {"min_words": 200, "max_words": 400},
+    "Long (400-600 words)": {"min_words": 400, "max_words": 600}
+}
+
+# Tone configurations
+TONES = {
+    "Professional": "formal, business-like, authoritative",
+    "Casual": "friendly, conversational, approachable",
+    "Enthusiastic": "energetic, passionate, motivating",
+    "Educational": "informative, instructional, helpful",
+    "Inspirational": "motivational, uplifting, encouraging"
+}
+
+# Default settings
+DEFAULT_SETTINGS = {
+    "post_length": "Medium (200-400 words)",
+    "tone": "Professional",
+    "include_hashtags": True,
+    "include_call_to_action": True,
+    "max_hashtags": 5,
+    "include_emoji": True
+}
+
+# Hashtag suggestions for common topics
+HASHTAG_SUGGESTIONS = {
+    "ai": ["#AI", "#ArtificialIntelligence", "#MachineLearning", "#Tech", "#Innovation"],
+    "leadership": ["#Leadership", "#Management", "#Business", "#ProfessionalDevelopment", "#Career"],
+    "remote_work": ["#RemoteWork", "#WorkFromHome", "#Productivity", "#DigitalTransformation", "#FutureOfWork"],
+    "healthcare": ["#Healthcare", "#HealthTech", "#DigitalHealth", "#Innovation", "#PatientCare"],
+    "business": ["#Business", "#Entrepreneurship", "#Strategy", "#Growth", "#Success"]
+}
+
+def get_generation_prompt(user_input, context="", settings=None):
+    """
+    Generate a formatted prompt for the AI agent based on user input and settings
+    """
+    if settings is None:
+        settings = DEFAULT_SETTINGS
+    
+    prompt = f"Create a LinkedIn post about: {user_input}"
+    
+    if context:
+        prompt += f"\n\nContext: {context}"
+    
+    # Add length requirements
+    length_config = POST_LENGTHS.get(settings.get("post_length", DEFAULT_SETTINGS["post_length"]))
+    prompt += f"\n\nLength: {length_config['min_words']}-{length_config['max_words']} words"
+    
+    # Add tone requirements
+    tone = settings.get("tone", DEFAULT_SETTINGS["tone"])
+    tone_description = TONES.get(tone, TONES["Professional"])
+    prompt += f"\n\nTone: {tone_description}"
+    
+    # Add hashtag requirements
+    if settings.get("include_hashtags", True):
+        max_hashtags = settings.get("max_hashtags", 5)
+        prompt += f"\n\nInclude {max_hashtags} relevant hashtags at the end"
+    
+    # Add call to action requirements
+    if settings.get("include_call_to_action", True):
+        prompt += "\n\nInclude a call to action at the end"
+    
+    # Add emoji requirements
+    if settings.get("include_emoji", True):
+        prompt += "\n\nUse emojis sparingly but effectively to enhance readability"
+    
+    # Add LinkedIn-specific formatting
+    prompt += "\n\nFormat the post for LinkedIn with proper paragraph breaks and engaging opening"
+    
+    return prompt
+
+def get_hashtag_suggestions(topic):
+    """
+    Get hashtag suggestions based on the topic
+    """
+    topic_lower = topic.lower()
+    
+    for key, hashtags in HASHTAG_SUGGESTIONS.items():
+        if key in topic_lower:
+            return hashtags
+    
+    # Return general hashtags if no specific match
+    return ["#LinkedIn", "#Professional", "#Networking", "#Career", "#Business"] 

helper/configure_llm.py

@@ -0,0 +1,20 @@
+import sys
+sys.dont_write_bytecode = True
+
+from langchain_openai import AzureChatOpenAI
+from config.configs import AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, OPENAI_API_VERSION, AZURE_DEPLOYMENT
+import os
+
+os.environ['AZURE_OPENAI_API_KEY'] = AZURE_OPENAI_API_KEY
+
+os.environ['OPENAI_API_VERSION'] = OPENAI_API_VERSION
+
+os.environ['AZURE_OPENAI_ENDPOINT'] = AZURE_OPENAI_ENDPOINT
+
+LLM = AzureChatOpenAI(
+    azure_deployment=AZURE_DEPLOYMENT, 
+    temperature=0,
+    max_tokens=None,
+    timeout=None,
+    max_retries=2,
+)

helper/graphs.py

@@ -0,0 +1,33 @@
+from langgraph.graph import END, StateGraph
+from helper.model_load import GraphState
+from utils.search_web_content import web_search
+from utils.query_transform import transform_query
+from utils.generate_content import generate
+from utils.question_route import route_question
+
+import sys
+sys.dont_write_bytecode = True
+
+builder = StateGraph(GraphState)
+
+builder.add_node("web_search", web_search)
+
+builder.add_node("transform_query", transform_query)
+
+builder.add_node("generate", generate)
+
+builder.set_conditional_entry_point(
+    route_question,
+    {
+        "websearch": "transform_query",
+        "generate": "generate"
+    },
+)
+
+builder.add_edge("transform_query", "web_search")
+
+builder.add_edge("web_search", "generate")
+
+builder.add_edge("generate", END)
+
+local_agent = builder.compile()

helper/model_load.py

@@ -0,0 +1,17 @@
+from typing import TypedDict
+import sys
+sys.dont_write_bytecode = True
+
+class GraphState(TypedDict):
+    """
+    Represents the state of our graph.
+    Attributes:
+        question: question
+        generation: LLM generation
+        search_query: revised question for web search
+        context: web_search result
+    """
+    question: str
+    generation: str
+    search_query: str
+    context: str

helper/web_search_agent.py

@@ -0,0 +1,16 @@
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
+
+import sys
+sys.dont_write_bytecode = True
+
+import sys
+sys.dont_write_bytecode = True
+
+WRAPPER = DuckDuckGoSearchAPIWrapper(
+    max_results=25
+)
+
+WEB_SEARCH_TOOL = DuckDuckGoSearchRun(
+    api_wrapper=WRAPPER
+)

loggers/logger.py

@@ -0,0 +1,29 @@
+import logging
+import os
+from datetime import datetime
+
+import sys
+sys.dont_write_bytecode = True
+
+log_dir = "logs"
+os.makedirs(log_dir, exist_ok=True)
+
+log_filename = datetime.now().strftime("log_%Y-%m-%d_%H-%M-%S.log")
+log_filepath = os.path.join(log_dir, log_filename)
+
+logger = logging.getLogger("project_logger")
+logger.setLevel(logging.DEBUG)
+
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+file_handler = logging.FileHandler(log_filepath)
+file_handler.setLevel(logging.DEBUG)
+file_handler.setFormatter(formatter)
+
+stream_handler = logging.StreamHandler()
+stream_handler.setLevel(logging.INFO)
+stream_handler.setFormatter(formatter)
+
+if not logger.handlers:
+    logger.addHandler(file_handler)
+    logger.addHandler(stream_handler)

requirements.txt

@@ -1,3 +1,9 @@
-altair
-pandas
-streamlit
+streamlit
+langchain
+langchain-core
+langchain-community
+langchain-openai
+langgraph
+langsmith
+duckduckgo-search
+python-dotenv

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

template/response_prompt.py

@@ -0,0 +1,36 @@
+from langchain.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from helper.configure_llm import LLM
+
+import sys
+sys.dont_write_bytecode = True
+
+llm = LLM
+
+GENERATE_TEMPLATE = PromptTemplate(
+    template = """
+
+    <|begin_of_text|>
+
+    <|start_header_id|>system<|end_header_id|>
+
+    You are an AI assistant that synthesizes web search results to create engaging and information LinkedIn posts that are clear, concise and appealing to professionals on LinkedIn.
+    Make sure the tone is professional yet approachable, and include actionable insights, tips or thought-provoking points that would resonate with the LinkedIn audience.
+    If relevant, include a call-to-action or a question to encourage engagement. Strictly use the following pieces of web search context to answer the question.
+    If you don't know, just say that you don't know. Only make direct references to material if provided in the context.
+
+    <|eot_id|>
+
+    <|start_header_id|>user<|end_header_id|>
+
+    Question: {question}
+    Web Search Context: {context}
+    Answer:
+
+    <|eot_id|>
+
+    <|start_header_id|>assistant<|end_header_id|>""",
+    input_variables=["question", "context"],
+)
+
+GENERATE_CHAIN = GENERATE_TEMPLATE | llm | StrOutputParser()

template/router_prompt.py

@@ -0,0 +1,34 @@
+from langchain.prompts import PromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+from helper.configure_llm import LLM
+
+import sys
+sys.dont_write_bytecode = True
+
+llm = LLM
+
+router_prompt = PromptTemplate(
+    template="""
+    
+    <|begin_of_text|>
+    
+    <|start_header_id|>system<|end_header_id|>
+    
+    You are an expert at routing a user question to either the generation stage or web search. 
+    Use the web search for questions that require more context for a better answer or recent events.
+    Otherwise, you can skip and go straight to the generation phase to respond.
+    You do not need to be stringent with the keywords in the question related to these topics.
+    Give a binary choice 'web_search' or 'generate' based on the question. 
+    Return the JSON with a single key 'choice' with no premable or explanation. 
+    
+    Question to route: {question} 
+    
+    <|eot_id|>
+    
+    <|start_header_id|>assistant<|end_header_id|>
+    
+    """,
+    input_variables=["question"],
+)
+
+QUESTION_ROUTER = router_prompt | llm | JsonOutputParser()

template/transform_prompt.py

@@ -0,0 +1,32 @@
+from langchain.prompts import PromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+from helper.configure_llm import LLM
+
+import sys
+sys.dont_write_bytecode = True
+
+llm = LLM
+
+QUERY_PROMPT = PromptTemplate(
+    template = """
+
+    <|begin_of_text|>
+
+    <|start_header_id|>system<|end_header_id|>
+
+    You are a expert at crafting web search queries for research questions.
+    More often that not, a user will ask a basic question that they wish to learn more about; however, it might not be in the best format.
+    Reword their query to be the most effective web search string possible.
+    Return the JSON with a single key 'query' with no premable or explanation.
+
+    Question to transform: {question}
+
+    <|eot_id|>
+
+    <|start_header_id|>user<|end_header_id|>
+
+    """,
+    input_variables=["question"],
+)
+
+QUERY_CHAIN = QUERY_PROMPT | llm | JsonOutputParser()

tests/llm_test.py

@@ -0,0 +1,21 @@
+from langchain_openai import AzureChatOpenAI
+from config.configs import AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, OPENAI_API_VERSION, AZURE_DEPLOYMENT
+import os
+
+os.environ['AZURE_OPENAI_API_KEY'] = AZURE_OPENAI_API_KEY
+
+os.environ['OPENAI_API_VERSION'] = OPENAI_API_VERSION
+
+os.environ['AZURE_OPENAI_ENDPOINT'] = AZURE_OPENAI_ENDPOINT
+
+LLM = AzureChatOpenAI(
+    azure_deployment=AZURE_DEPLOYMENT, 
+    temperature=0,
+    max_tokens=None,
+    timeout=None,
+    max_retries=2,
+)
+
+if __name__ == "__main__":
+    response = LLM.invoke("hello, how are you")
+    print(response)

tests/search_test.py

@@ -0,0 +1,8 @@
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
+
+wrapper = DuckDuckGoSearchAPIWrapper(max_results=25)
+web_search_tool = DuckDuckGoSearchRun(api_wrapper=wrapper)
+
+rep = web_search_tool.invoke("Who won 2025 Champions Trophy")
+print(rep)

utils/credential_manager.py

@@ -0,0 +1,102 @@
+"""
+Credential management utilities for Azure OpenAI
+"""
+
+import os
+import streamlit as st
+from typing import Dict, Optional, Tuple
+
+class CredentialManager:
+    """Manages Azure OpenAI credentials for the application"""
+    
+    @staticmethod
+    def get_credentials_from_env() -> Dict[str, str]:
+        """Get credentials from environment variables"""
+        return {
+            'api_key': os.getenv('AZURE_OPENAI_API_KEY', ''),
+            'endpoint': os.getenv('AZURE_OPENAI_ENDPOINT', ''),
+            'deployment': os.getenv('AZURE_DEPLOYMENT', ''),
+            'api_version': os.getenv('OPENAI_API_VERSION', '2024-02-01')
+        }
+    
+    @staticmethod
+    def get_credentials_from_session() -> Dict[str, str]:
+        """Get credentials from Streamlit session state"""
+        return {
+            'api_key': st.session_state.get('azure_api_key', ''),
+            'endpoint': st.session_state.get('azure_endpoint', ''),
+            'deployment': st.session_state.get('azure_deployment', ''),
+            'api_version': st.session_state.get('azure_api_version', '2024-02-01')
+        }
+    
+    @staticmethod
+    def save_credentials_to_session(api_key: str, endpoint: str, deployment: str, api_version: str = '2024-02-01'):
+        """Save credentials to Streamlit session state"""
+        st.session_state.azure_api_key = api_key
+        st.session_state.azure_endpoint = endpoint
+        st.session_state.azure_deployment = deployment
+        st.session_state.azure_api_version = api_version
+    
+    @staticmethod
+    def set_environment_variables(credentials: Dict[str, str]):
+        """Set environment variables for Azure OpenAI"""
+        os.environ['AZURE_OPENAI_API_KEY'] = credentials['api_key']
+        os.environ['AZURE_OPENAI_ENDPOINT'] = credentials['endpoint']
+        os.environ['AZURE_DEPLOYMENT'] = credentials['deployment']
+        os.environ['OPENAI_API_VERSION'] = credentials['api_version']
+    
+    @staticmethod
+    def validate_credentials(credentials: Dict[str, str]) -> Tuple[bool, str]:
+        """Validate Azure OpenAI credentials"""
+        if not credentials['api_key']:
+            return False, "API Key is required"
+        
+        if not credentials['endpoint']:
+            return False, "Endpoint is required"
+        
+        if not credentials['deployment']:
+            return False, "Deployment name is required"
+        
+        # Basic format validation for Azure OpenAI
+        if len(credentials['api_key']) < 10:
+            return False, "API Key seems too short"
+        
+        if not credentials['endpoint'].startswith('https://'):
+            return False, "Endpoint should be a valid HTTPS URL"
+        
+        if not credentials['endpoint'].endswith('.openai.azure.com/'):
+            return False, "Endpoint should end with '.openai.azure.com/'"
+        
+        return True, "Credentials are valid"
+    
+    @staticmethod
+    def get_current_credentials(use_env: bool = True) -> Dict[str, str]:
+        """Get current credentials based on preference"""
+        if use_env:
+            return CredentialManager.get_credentials_from_env()
+        else:
+            return CredentialManager.get_credentials_from_session()
+    
+    @staticmethod
+    def clear_session_credentials():
+        """Clear credentials from session state"""
+        if 'azure_api_key' in st.session_state:
+            del st.session_state.azure_api_key
+        if 'azure_endpoint' in st.session_state:
+            del st.session_state.azure_endpoint
+        if 'azure_deployment' in st.session_state:
+            del st.session_state.azure_deployment
+        if 'azure_api_version' in st.session_state:
+            del st.session_state.azure_api_version
+
+def format_endpoint_url(endpoint: str) -> str:
+    """Format endpoint URL to ensure it ends with a slash"""
+    if not endpoint.endswith('/'):
+        endpoint += '/'
+    return endpoint
+
+def mask_api_key(api_key: str) -> str:
+    """Mask API key for display purposes"""
+    if len(api_key) > 8:
+        return api_key[:4] + '*' * (len(api_key) - 8) + api_key[-4:]
+    return '*' * len(api_key) 

utils/generate_content.py

@@ -0,0 +1,33 @@
+from loggers.logger import logger
+from template.response_prompt import GENERATE_CHAIN
+
+import sys
+sys.dont_write_bytecode = True
+
+def generate(state):
+    """
+    Generate Answer
+    Args:
+        state (dict): The current graph state
+    Return:
+        state (dict): New key added to state
+    """
+    
+    logger.info("STEP: GENERATING FINAL RESPONSE")
+
+    question = state['question']
+
+    try:
+        context = state['context']
+    except:
+        context = " "
+    
+    generation = GENERATE_CHAIN.invoke(
+        {
+            "context": context,
+            "question": question
+        }
+    )
+    return {
+        "generation": generation
+    }

utils/query_transform.py

@@ -0,0 +1,28 @@
+from loggers.logger import logger
+from template.transform_prompt import QUERY_CHAIN
+
+import sys
+sys.dont_write_bytecode = True
+
+query_chain = QUERY_CHAIN
+
+def transform_query(state):
+    """
+    Transform the user query to web search
+    Args:
+        state (dict): The current graph state
+    Returns:
+        state (dict): Appended search query
+    """
+
+    logger.info("INSIDE QUERY TRANSFORMATION FOR WEB SEARCH")
+    
+    question = state['question']
+    
+    gen_question = query_chain.invoke({"question": question})
+    
+    search_query = gen_question['query']
+    
+    return {
+        "search_query": search_query
+    }

utils/question_route.py

@@ -0,0 +1,37 @@
+from loggers.logger import logger
+from template.router_prompt import QUESTION_ROUTER
+
+import sys
+sys.dont_write_bytecode = True
+
+query_router = QUESTION_ROUTER
+
+def route_question(state):
+    """
+    Route question to web search or generation.
+    Args:
+        state (dict): The current graph state
+    Returns:
+        str: Next node to call
+    """
+
+    logger.info("INSIDE ROUTE QUESTION FUNCTION")
+
+    question = state['question']
+    
+    output = query_router.invoke(
+        {
+            "question": question
+        }
+    )
+
+    if output['choice'] == "web_search":
+        logger.info("ROUTING QUERY TO WEB SEARCH CONTENT")
+        return "websearch"
+
+    elif output['choice'] == "generate":
+        logger.info("ROUTING QUERY TO GENERATION CONTENT")
+        return "generate"
+    
+    
+

utils/run_agent.py

@@ -0,0 +1,15 @@
+from helper.graphs import local_agent
+
+import sys
+sys.dont_write_bytecode = True
+
+def execute_agent(query):
+    output = local_agent.invoke(
+        {
+            "question": query
+        }
+    )
+
+    return output['generation']
+
+print(execute_agent("What is AI"))

utils/search_web_content.py

@@ -0,0 +1,35 @@
+from loggers.logger import logger
+from helper.web_search_agent import WEB_SEARCH_TOOL
+
+import sys
+sys.dont_write_bytecode = True
+
+tool = WEB_SEARCH_TOOL
+
+def web_search(state):
+    """
+    Route question to web search
+    Args:
+        state (dict): The current graph state
+    Returns:
+        state (dict): Next node to call
+    """
+    
+    logger.info("INSIDE THE WEB SEARCH FILE")
+
+    query = state['search_query']
+
+    logger.info(f"SEARCH QUERY ENTERED: {query}")
+
+    result = WEB_SEARCH_TOOL.invoke(query)
+
+    logger.info("WEB SEARCH TOOL INVOKED")
+
+    return {
+        "context": result
+    }
+
+
+
+
+