Upload 9 files

# 🖼️ Multi-Model Image Caption Generator

A powerful Streamlit application that generates captions for images using multiple AI models (OpenAI GPT-4o, Google Gemini, and GROQ Vision) with advanced image processing capabilities using OpenCV and LangChain for history management.

## ✨ Features

- **Multi-Model Support**: Choose from OpenAI GPT-4o, Google Gemini, or GROQ Vision models
- **Smart Caption Generation**: Clean, professional captions (10-50 words, no emojis/symbols)
- **Advanced Image Processing**: Two caption overlay methods using OpenCV
- **LangChain Integration**: Comprehensive history management and conversation memory
- **Custom Typography**: Uses Poppins font with intelligent fallbacks
- **Interactive UI**: Modern Streamlit interface with real-time preview
- **Export Functionality**: Download processed images with captions

## 🚀 Quick Start

### Prerequisites

- Python 3.8+
- API keys for at least one of the supported models

### Installation

1. **Clone the repository**
```bash
git clone <your-repo-url>
cd multi-model-caption-generator
```

2. **Install dependencies**
```bash
pip install streamlit opencv-python pillow openai google-generativeai groq langchain python-dotenv
```

3. **Set up environment variables**
Create a `.env` file in the project root:
```env
OPENAI_API_KEY_IC=your_openai_api_key_here
GEMINI_API_KEY_IC=your_gemini_api_key_here
GROQ_API_KEY_IC=your_groq_api_key_here
```

4. **Set up fonts (optional)**
Place your font file at:
```
fonts/Poppins-Regular.ttf
```

5. **Run the application**
```bash
streamlit run main.py
```

## 📁 Project Structure

```
multi-model-caption-generator/
├── main.py # Main Streamlit application
├── caption_generation.py # Multi-model caption generation
├── caption_history.py # LangChain history management
├── caption_overlay.py # OpenCV image processing
├── fonts/ # Font directory
│ └── Poppins-Regular.ttf # Custom font (optional)
├── .env # Environment variables
├── caption_history.json # Auto-generated history file
└── README.md # This file
```

## 🤖 Supported AI Models

### OpenAI GPT-4o
- **Model**: `gpt-4o`
- **Strengths**: Detailed image analysis, high accuracy
- **API**: OpenAI Vision API

### Google Gemini
- **Model**: `gemini-1.5-flash`
- **Strengths**: Fast processing, multimodal understanding
- **API**: Google Generative AI

### GROQ Vision
- **Model**: `llama-3.2-11b-vision-preview`
- **Strengths**: High-speed inference, efficient processing
- **API**: GROQ API

## 🎨 Caption Overlay Options

### 1. Overlay on Image
- Position: Top, Center, or Bottom
- Customizable font size and thickness
- Auto text wrapping for long captions
- Semi-transparent background for readability

### 2. Background Behind Image
- Caption appears above the image
- Customizable background and text colors
- Adjustable margins
- Uses Poppins font with fallbacks

## 📝 Caption History Management

The application uses LangChain for sophisticated history management:

- **Persistent Storage**: All captions saved to `caption_history.json`
- **Memory Integration**: LangChain ConversationBufferMemory
- **Search & Filter**: Find previous captions by image name or content
- **Export History**: View and manage generation history

## 🔧 Configuration

### API Keys Setup

Get your API keys from:
- **OpenAI**: [https://platform.openai.com/api-keys](https://platform.openai.com/api-keys)
- **Google Gemini**: [https://makersuite.google.com/app/apikey](https://makersuite.google.com/app/apikey)
- **GROQ**: [https://console.groq.com/keys](https://console.groq.com/keys)

### Font Configuration

The app automatically uses fonts in this priority:
1. Custom font path (if specified in UI)
2. `fonts/Poppins-Regular.ttf` (if available)
3. System default font

### Caption Settings

- **Word Limit**: 10-50 words maximum
- **Format**: Plain text only (no emojis or special characters)
- **Style**: Descriptive but concise

## 🖥️ Usage

1. **Configure APIs**: Add your API keys to `.env` file and click "Configure APIs"
2. **Upload Image**: Choose PNG, JPG, JPEG, BMP, or TIFF files
3. **Select Model**: Choose from OpenAI, Gemini, or GROQ
4. **Generate Caption**: Click to generate and see real-time preview
5. **Customize Overlay**: Adjust position, colors, and styling
6. **Download**: Save the final image with caption

## 🎯 Key Features Explained

### Smart Caption Generation
- All models generate clean, professional captions
- Consistent 10-50 word length
- No emojis or special characters
- Perfect for image overlays

### Advanced Image Processing
- OpenCV-powered text rendering
- Automatic text wrapping
- High-quality font rendering with PIL
- Multiple overlay styles

### History Management
- LangChain integration for conversation memory
- Searchable history with timestamps
- Model tracking for each generation
- Easy history clearing and management

## 🛠️ Technical Details

### Dependencies
```
streamlit>=1.28.0
opencv-python>=4.8.0
pillow>=10.0.0
openai>=1.0.0
google-generativeai>=0.3.0
groq>=0.4.0
langchain>=0.1.0
python-dotenv>=1.0.0
numpy>=1.24.0
```

### Performance Optimizations
- Efficient base64 encoding for API calls
- Optimized image processing with OpenCV
- Smart memory management with LangChain
- Reduced token limits for faster generation

## 🔍 Troubleshooting

### Common Issues

**API Key Errors**
- Ensure all API keys are correctly set in `.env` file
- Check API key validity and quotas
- Restart the application after adding keys

**Font Loading Issues**
- Verify font file exists at `fonts/Poppins-Regular.ttf`
- Check file permissions
- App will fallback to default font if custom font fails

**Image Processing Errors**
- Ensure uploaded images are valid formats
- Check image file size (very large images may cause issues)
- Try different image formats if problems persist

**Model-Specific Issues**
- **OpenAI**: Verify you have access to GPT-4o vision model
- **Gemini**: Ensure Gemini API is enabled in your Google Cloud project
- **GROQ**: Check that vision models are available in your region

### Error Messages

| Error | Solution |
|-------|----------|
| "API key not configured" | Add the required API key to `.env` file |
| "Model not available" | Check model name and API access |
| "Image processing failed" | Try a different image format or size |
| "Font loading error" | Check font file path or use default font |

## 🤝 Contributing

1. Fork the repository
2. Create a feature branch: `git checkout -b feature-name`
3. Make your changes and commit: `git commit -m 'Add feature'`
4. Push to the branch: `git push origin feature-name`
5. Submit a pull request

## 📄 License

This project is licensed under the MIT License - see the [MIT LICENSE](https://mit-license.org/) file for details.

## 🙏 Acknowledgments

- **Streamlit** for the amazing web app framework
- **OpenCV** for powerful image processing capabilities
- **LangChain** for conversation memory management
- **OpenAI, Google, and GROQ** for providing excellent vision APIs
- **Poppins Font** for beautiful typography

## 📞 Support

If you encounter any issues or have questions:

1. Check the troubleshooting section above
2. Review the [Issues](https://github.com/your-repo/issues) page
3. Create a new issue with detailed information
4. Provide error messages and steps to reproduce

---

**Built with ❤️ using Streamlit, LangChain, OpenCV, and multi-model AI APIs**

.env

@@ -0,0 +1,3 @@
+OPENAI_API_KEY_IC = "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"
+GEMINI_API_KEY_IC ="AIzaSyC2zOnkcC5bK0zmWgszdjO8bhMf3sRHZsM"
+GROQ_API_KEY_IC = "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"

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

README.md

@@ -1,20 +1,245 @@
----
-title: Multi LLM Image Captioning
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: A comprehensive multi-model image caption generator.
-license: mit
----
+# 🖼️ Multi-Model Image Caption Generator
+
+A powerful Streamlit application that generates captions for images using multiple AI models (OpenAI GPT-4o, Google Gemini, and GROQ Vision) with advanced image processing capabilities using OpenCV and LangChain for history management.
+
+## ✨ Features
+
+- **Multi-Model Support**: Choose from OpenAI GPT-4o, Google Gemini, or GROQ Vision models
+- **Smart Caption Generation**: Clean, professional captions (10-50 words, no emojis/symbols)
+- **Advanced Image Processing**: Two caption overlay methods using OpenCV
+- **LangChain Integration**: Comprehensive history management and conversation memory
+- **Custom Typography**: Uses Poppins font with intelligent fallbacks
+- **Interactive UI**: Modern Streamlit interface with real-time preview
+- **Export Functionality**: Download processed images with captions
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.8+
+- API keys for at least one of the supported models
+
+### Installation
+
+1. **Clone the repository**
+```bash
+git clone <your-repo-url>
+cd multi-model-caption-generator
+```
+
+2. **Install dependencies**
+```bash
+pip install streamlit opencv-python pillow openai google-generativeai groq langchain python-dotenv
+```
+
+3. **Set up environment variables**
+Create a `.env` file in the project root:
+```env
+OPENAI_API_KEY_IC=your_openai_api_key_here
+GEMINI_API_KEY_IC=your_gemini_api_key_here
+GROQ_API_KEY_IC=your_groq_api_key_here
+```
+
+4. **Set up fonts (optional)**
+Place your font file at:
+```
+fonts/Poppins-Regular.ttf
+```
+
+5. **Run the application**
+```bash
+streamlit run main.py
+```
+
+## 📁 Project Structure
+
+```
+multi-model-caption-generator/
+├── main.py                    # Main Streamlit application
+├── caption_generation.py     # Multi-model caption generation
+├── caption_history.py        # LangChain history management
+├── caption_overlay.py        # OpenCV image processing
+├── fonts/                    # Font directory
+│   └── Poppins-Regular.ttf   # Custom font (optional)
+├── .env                      # Environment variables
+├── caption_history.json     # Auto-generated history file
+└── README.md                # This file
+```
+
+## 🤖 Supported AI Models
+
+### OpenAI GPT-4o
+- **Model**: `gpt-4o`
+- **Strengths**: Detailed image analysis, high accuracy
+- **API**: OpenAI Vision API
+
+### Google Gemini
+- **Model**: `gemini-1.5-flash`
+- **Strengths**: Fast processing, multimodal understanding
+- **API**: Google Generative AI
+
+### GROQ Vision
+- **Model**: `llama-3.2-11b-vision-preview`
+- **Strengths**: High-speed inference, efficient processing
+- **API**: GROQ API
+
+## 🎨 Caption Overlay Options
+
+### 1. Overlay on Image
+- Position: Top, Center, or Bottom
+- Customizable font size and thickness
+- Auto text wrapping for long captions
+- Semi-transparent background for readability
+
+### 2. Background Behind Image
+- Caption appears above the image
+- Customizable background and text colors
+- Adjustable margins
+- Uses Poppins font with fallbacks
+
+## 📝 Caption History Management
+
+The application uses LangChain for sophisticated history management:
+
+- **Persistent Storage**: All captions saved to `caption_history.json`
+- **Memory Integration**: LangChain ConversationBufferMemory
+- **Search & Filter**: Find previous captions by image name or content
+- **Export History**: View and manage generation history
+
+## 🔧 Configuration
+
+### API Keys Setup
+
+Get your API keys from:
+- **OpenAI**: [https://platform.openai.com/api-keys](https://platform.openai.com/api-keys)
+- **Google Gemini**: [https://makersuite.google.com/app/apikey](https://makersuite.google.com/app/apikey)
+- **GROQ**: [https://console.groq.com/keys](https://console.groq.com/keys)
+
+### Font Configuration
 
-# Welcome to Streamlit!
+The app automatically uses fonts in this priority:
+1. Custom font path (if specified in UI)
+2. `fonts/Poppins-Regular.ttf` (if available)
+3. System default font
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+### Caption Settings
+
+- **Word Limit**: 10-50 words maximum
+- **Format**: Plain text only (no emojis or special characters)
+- **Style**: Descriptive but concise
+
+## 🖥️ Usage
+
+1. **Configure APIs**: Add your API keys to `.env` file and click "Configure APIs"
+2. **Upload Image**: Choose PNG, JPG, JPEG, BMP, or TIFF files
+3. **Select Model**: Choose from OpenAI, Gemini, or GROQ
+4. **Generate Caption**: Click to generate and see real-time preview
+5. **Customize Overlay**: Adjust position, colors, and styling
+6. **Download**: Save the final image with caption
+
+## 🎯 Key Features Explained
+
+### Smart Caption Generation
+- All models generate clean, professional captions
+- Consistent 10-50 word length
+- No emojis or special characters
+- Perfect for image overlays
+
+### Advanced Image Processing
+- OpenCV-powered text rendering
+- Automatic text wrapping
+- High-quality font rendering with PIL
+- Multiple overlay styles
+
+### History Management
+- LangChain integration for conversation memory
+- Searchable history with timestamps
+- Model tracking for each generation
+- Easy history clearing and management
+
+## 🛠️ Technical Details
+
+### Dependencies
+```
+streamlit>=1.28.0
+opencv-python>=4.8.0
+pillow>=10.0.0
+openai>=1.0.0
+google-generativeai>=0.3.0
+groq>=0.4.0
+langchain>=0.1.0
+python-dotenv>=1.0.0
+numpy>=1.24.0
+```
+
+### Performance Optimizations
+- Efficient base64 encoding for API calls
+- Optimized image processing with OpenCV
+- Smart memory management with LangChain
+- Reduced token limits for faster generation
+
+## 🔍 Troubleshooting
+
+### Common Issues
+
+**API Key Errors**
+- Ensure all API keys are correctly set in `.env` file
+- Check API key validity and quotas
+- Restart the application after adding keys
+
+**Font Loading Issues**
+- Verify font file exists at `fonts/Poppins-Regular.ttf`
+- Check file permissions
+- App will fallback to default font if custom font fails
+
+**Image Processing Errors**
+- Ensure uploaded images are valid formats
+- Check image file size (very large images may cause issues)
+- Try different image formats if problems persist
+
+**Model-Specific Issues**
+- **OpenAI**: Verify you have access to GPT-4o vision model
+- **Gemini**: Ensure Gemini API is enabled in your Google Cloud project
+- **GROQ**: Check that vision models are available in your region
+
+### Error Messages
+
+| Error | Solution |
+|-------|----------|
+| "API key not configured" | Add the required API key to `.env` file |
+| "Model not available" | Check model name and API access |
+| "Image processing failed" | Try a different image format or size |
+| "Font loading error" | Check font file path or use default font |
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature-name`
+3. Make your changes and commit: `git commit -m 'Add feature'`
+4. Push to the branch: `git push origin feature-name`
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [MIT LICENSE](https://mit-license.org/) file for details.
+
+## 🙏 Acknowledgments
+
+- **Streamlit** for the amazing web app framework
+- **OpenCV** for powerful image processing capabilities
+- **LangChain** for conversation memory management
+- **OpenAI, Google, and GROQ** for providing excellent vision APIs
+- **Poppins Font** for beautiful typography
+
+## 📞 Support
+
+If you encounter any issues or have questions:
+
+1. Check the troubleshooting section above
+2. Review the [Issues](https://github.com/your-repo/issues) page
+3. Create a new issue with detailed information
+4. Provide error messages and steps to reproduce
+
+---
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+**Built with ❤️ using Streamlit, LangChain, OpenCV, and multi-model AI APIs**

caption_generation.py

@@ -0,0 +1,116 @@
+import base64
+import io
+import os
+from PIL import Image
+
+# API Imports
+import openai
+import google.generativeai as genai
+from groq import Groq
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+openai_key = os.getenv("OPENAI_API_KEY_IC")
+gemini_key = os.getenv("GEMINI_API_KEY_IC")
+groq_key = os.getenv("GROQ_API_KEY_IC")
+
+class MultiModelCaptionGenerator:
+    """Handles caption generation using multiple models."""
+    def __init__(self):
+        self.openai_client = None
+        self.groq_client = None
+        self.gemini_configured = False
+
+    def configure_apis(self, openai_key: str|None = openai_key, groq_key: str|None = groq_key,
+        gemini_key: str|None = gemini_key):
+
+        if openai_key:
+            self.openai_client = openai.OpenAI(api_key=openai_key)
+
+        if groq_key:
+            self.groq_client = Groq(api_key=groq_key)
+
+        if gemini_key:
+            genai.configure(api_key=gemini_key)
+            self.gemini_configured = True
+
+    def encode_image_base64(self, image: Image.Image) -> str:
+        buffered = io.BytesIO()
+        image.save(buffered, format="PNG")
+        return base64.b64encode(buffered.getvalue()).decode()
+    
+    def generate_caption_openai(self, image: Image.Image, model: str = "gpt-4o-mini") -> str:
+        """Fixed OpenAI caption generation with correct model and image_url format"""
+        if not self.openai_client:
+            raise ValueError("OpenAI API key not configured.")
+        
+        base64_image = self.encode_image_base64(image)
+
+        response = self.openai_client.chat.completions.create(
+            model=model,  # Use gpt-4o or gpt-4o-mini for vision
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Generate the caption for this image. IMPORTANT: Use 10 words or 50 characters maximum. Use only plain text - no emojis, special character but can use ASCII punctuations if you want. Be descriptive but concise."
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/png;base64,{base64_image}"  # Fixed: removed space after comma
+                            }
+                        }
+                    ]
+                }
+            ],
+            max_tokens=300
+        )
+        return response.choices[0].message.content 
+    
+    def generate_caption_gemini(self, image: Image.Image, 
+    model: str = "gemini-2.5-flash") -> str:  # Fixed: use correct model name
+        """Fixed Gemini caption generation with correct model name"""
+        if not self.gemini_configured:
+            raise ValueError("Gemini API key not configured!")
+        
+        model_instance = genai.GenerativeModel(model)
+        prompt = "Generate the caption for this image. IMPORTANT: Use 10 words or 50 characters maximum. Use only plain text - no emojis, special character but can use ASCII punctuations if you want. Be descriptive but concise."
+
+        response = model_instance.generate_content([prompt, image])
+        return response.text
+    
+    def generate_caption_groq(self, image: Image.Image, 
+    model: str = "meta-llama/llama-4-scout-17b-16e-instruct") -> str:  
+        """Fixed GROQ caption generation with correct model name and API structure"""
+        if not self.groq_client:
+            raise ValueError("GROQ API key is not configured!")
+        
+        base64_image = self.encode_image_base64(image)
+
+        completion = self.groq_client.chat.completions.create(
+            model=model,  # Fixed: added missing model parameter
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Generate the caption for this image. IMPORTANT: Use 10 words or 50 characters maximum. Use only plain text - no emojis, special character but can use ASCII punctuations if you want. Be descriptive but concise."
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/png;base64,{base64_image}"  # Fixed: proper format with url key
+                            }
+                        }
+                    ]
+                }
+            ],
+            max_tokens=300,
+            temperature=0.7
+        )
+        return completion.choices[0].message.content

caption_history.json

@@ -0,0 +1,110 @@
+[
+  {
+    "timestamp": "2025-06-28T11:06:08.409242",
+    "image_name": "ChatGPT Image Jun 27, 2025, 09_59_51 AM.png",
+    "model": "Google Gemini",
+    "caption": "Here are a few options, choose the one that best fits your tone:\n\n**Option 1 (Focus on Spectacle):**\n\"Witness the vibrant energy of a grand procession! Thousands of devotees in traditional orange and white attire pull three towering, ornate chariots, as a shower of golden petals fills the sky. A powerful display of collective devotion.\"\n\n**Option 2 (More direct):**\n\"A sea of devotees in orange and white tirelessly pull magnificent, ornate chariots under a shower of golden petals. This grand spectacle of faith and collective effort is truly awe-inspiring.\"\n\n**Option 3 (Slightly shorter):**\n\"Thousands of devotees in vibrant orange and white attire pull three magnificent chariots, as a cascade of golden petals rains from the sky. A powerful scene of spiritual celebration and unity.\""
+  },
+  {
+    "timestamp": "2025-06-28T11:17:53.982671",
+    "image_name": "ChatGPT Image Jun 27, 2025, 09_59_51 AM.png",
+    "model": "Google Gemini",
+    "caption": "A magnificent procession unfolds as a vast multitude, many in vibrant orange attire, collectively pulls enormous, ornate chariots. Golden and orange leaves rain down from the sky, creating a breathtaking and powerful spectacle of devotion and tradition."
+  },
+  {
+    "timestamp": "2025-06-28T11:31:29.073833",
+    "image_name": "ChatGPT Image Jun 24, 2025, 09_02_19 AM.png",
+    "model": "Google Gemini",
+    "caption": "Here's a detailed and engaging caption for the image:\n\nNostalgia activated! \u2728 Dive back into the pixel-perfect world of Super Mario with this iconic scene. From the classic question block and a gleaming coin to that instantly recognizable mushroom, it's all set against the vibrant blue sky and green hills we know and love. Pure retro gaming joy! What's your favorite Super Mario memory or level?\n\n#SuperMario #Nintendo #RetroGaming #GamingNostalgia #ClassicGames #MarioBros #PixelArt #ChildhoodMemories #MushroomKingdom #VideoGames"
+  },
+  {
+    "timestamp": "2025-06-28T11:55:38.783106",
+    "image_name": "ChatGPT Image Jun 27, 2025, 09_59_51 AM.png",
+    "model": "Google Gemini",
+    "caption": "Here are a few options for a detailed and engaging caption, keeping it descriptive yet concise:\n\n**Option 1 (Focus on atmosphere & common knowledge):**\nA breathtaking display of devotion and collective energy, as a vast multitude of devotees in vibrant orange pull three magnificent, ornate chariots. A shower of colorful petals or confetti rains down from the sky, highlighting the grandeur and joyous spirit of this spiritual procession.\n\n**Option 2 (More specific, if Ratha Yatra is identified):**\nThe vibrant spectacle of a Ratha Yatra festival, with thousands of devotees pulling the colossal, richly decorated chariots. A cascade of orange and yellow petals fills the air, adding a festive and sacred touch to this powerful demonstration of faith.\n\n**Option 3 (Concise and evocative):**\nA powerful scene of celebration and spiritual fervor, where a sea of people in saffron hues pulls three majestic, golden chariots. The sky above showers down a joyous burst of colorful confetti, capturing the dynamic energy of this grand procession."
+  },
+  {
+    "timestamp": "2025-06-28T11:56:31.347041",
+    "image_name": "ChatGPT Image Jun 27, 2025, 09_59_51 AM.png",
+    "model": "Google Gemini",
+    "caption": "Here are a few options for a detailed and engaging caption, playing with slightly different focuses:\n\n**Option 1 (Focus on spectacle & devotion):**\n\"A breathtaking display of devotion at the Ratha Yatra festival! Thousands of devotees unite to pull the majestic, ornate chariots, as a shower of auspicious petals blesses the vibrant procession. An incredible testament to faith and community.\"\n\n**Option 2 (Focus on energy & scale):**\n\"Experience the electrifying energy of the Ratha Yatra! A sea of devotees, clad in traditional orange and white, meticulously pull the colossal, brightly adorned chariots under a sky alive with falling blossoms. A truly grand spiritual spectacle.\"\n\n**Option 3 (More concise & evocative):**\n\"Majestic chariots, propelled by a vibrant sea of devotees, embark on their sacred journey during Ratha Yatra. The air shimmers with collective devotion and a shower of auspicious blessings from above.\""
+  },
+  {
+    "timestamp": "2025-06-28T12:37:12.999773",
+    "image_name": "ChatGPT Image Jun 27, 2025, 09_59_51 AM.png",
+    "model": "Google Gemini",
+    "caption": "Here are a few options, choose the one that best fits your platform/tone:\n\n**Option 1 (Concise & Evocative):**\nA powerful scene of devotion unfolds as thousands pull the colossal, ornately decorated chariots of a grand procession. Golden and fiery petals rain down from the sky, enhancing the vibrant, spiritual atmosphere of this ancient tradition.\n\n**Option 2 (Slightly more descriptive):**\nWitness the immense energy of a traditional festival, where countless devotees in vibrant attire pull majestic, multi-tiered chariots. The sky above showers golden and orange petals, adding a sacred and celebratory feel to this grand display of faith.\n\n**Option 3 (Short & Sweet):**\nThousands of devotees unite to pull magnificent chariots in a grand procession, as a shower of colorful petals blesses the vibrant spiritual atmosphere."
+  },
+  {
+    "timestamp": "2025-06-28T12:37:35.022969",
+    "image_name": "ChatGPT Image Jun 27, 2025, 09_59_51 AM.png",
+    "model": "Google Gemini",
+    "caption": "Here's a detailed yet concise and engaging caption for the image:\n\n\"A magnificent Ratha Yatra procession unfolds, as grand, ornate chariots of red and gold are pulled through a vast sea of devoted pilgrims dressed in vibrant orange. The sky above is showered with countless golden petals, adding a breathtaking, celebratory energy to this ancient and spiritual spectacle.\""
+  },
+  {
+    "timestamp": "2025-06-28T12:38:09.032392",
+    "image_name": "ChatGPT Image Jun 27, 2025, 09_59_51 AM.png",
+    "model": "Google Gemini",
+    "caption": "A vibrant spectacle of devotion unfolds as hundreds of people, primarily in saffron and white attire, collectively pull colossal, intricately designed chariots across a vast open ground. The sky above showers them with a beautiful cascade of golden and red leaves or petals, adding a festive and sacred ambiance to this powerful display of community and faith."
+  },
+  {
+    "timestamp": "2025-06-29T10:30:43.414914",
+    "image_name": "ChatGPT Image Jun 29, 2025, 01_58_05 AM.png",
+    "model": "OpenAI GPT-4o",
+    "caption": "\"Unlocking the power of AI with a few lines of code! This snippet showcases an asynchronous chat function using `httpx` and Google's Generative AI. The `chat` function establishes a client connection, initiates the Gemini Pro model, and sends a simple greeting \u2014 'Hello!' \u2014 to demonstrate seamless interaction. It's a perfect blend of modern programming practices and innovative technology, paving the way for dynamic, automated conversations!\""
+  },
+  {
+    "timestamp": "2025-06-29T10:31:19.761048",
+    "image_name": "ChatGPT Image Jun 29, 2025, 01_58_05 AM.png",
+    "model": "Google Gemini",
+    "caption": "Here are a few options for a detailed and engaging caption, keeping it descriptive yet concise:\n\n**Option 1 (Concise & Impactful):**\n\n> Say 'Hello!' to Google Gemini Pro with just a few lines of Python! This asynchronous snippet shows how incredibly simple it is to kickstart a conversational AI using `google.generativeai` and `httpx`. Ready to build your next intelligent app?\n>\n> \\#Python #GenerativeAI #GeminiPro #AIdevelopment\n\n**Option 2 (Slightly More Descriptive, Developer-Focused):**\n\n> Powering conversations with Python and Google Gemini Pro! \ud83d\ude80 This clean code snippet demonstrates how to asynchronously connect to the `gemini-pro` model, initiate a chat, and send your first message. Leverages `httpx` for efficient network calls, making AI integration smoother than ever. What brilliant bot will you create?\n>\n> \\#AI #Python #GeminiAPI #AsyncPython #MachineLearning\n\n**Option 3 (Engaging Tone):**\n\n> Witness the magic of Generative AI in action! \u2728 This elegant Python code reveals how effortlessly you can start a conversation with Google's powerful `gemini-pro` model. Using `async/await` for modern, non-blocking operations, it's never been easier to infuse your applications with intelligent chat capabilities. Send your first 'Hello!' to the future!\n>\n> \\#Code #AI #GoogleAI #PythonDev #Chatbot"
+  },
+  {
+    "timestamp": "2025-06-29T10:36:09.609008",
+    "image_name": "ChatGPT Image Jun 29, 2025, 01_58_05 AM.png",
+    "model": "OpenAI GPT-4o",
+    "caption": "\ud83d\ude80 Dive into the exciting realm of asynchronous programming with this Python snippet! \ud83d\udcbb\u2728\n\nHere, we harness the power of the Google Generative AI model, 'gemini-pro', to create an interactive chat experience. With the `httpx` library, we're establishing a streamlined, asynchronous connection, allowing for efficient network calls. The code showcases the seamless integration of AI, where it awaits a response after sending a greeting message. \n\nWhether you're a budding coder or an experienced developer, this snippet is a gateway to explore dynamic chat applications and the fascinating possibilities of AI integration. Let's code the future! \ud83c\udf10\ud83e\udd16"
+  },
+  {
+    "timestamp": "2025-06-29T10:45:45.277825",
+    "image_name": "ChatGPT Image Jun 22, 2025, 12_23_42 AM.png",
+    "model": "OpenAI GPT-4o",
+    "caption": "\"Unraveling patterns in complex data: This illustration captures the essence of logistic regression applied to cancer datasets. As the curve artfully bridges two distinct groups represented by orange and blue scatter points, it highlights the critical role of data analysis in healthcare. The hospital icon signifies the ultimate goal: utilizing data-driven insights to improve patient outcomes and advance cancer research. A powerful reminder of how statistics can illuminate pathways to better health and innovation!\""
+  },
+  {
+    "timestamp": "2025-06-29T10:46:09.997416",
+    "image_name": "ChatGPT Image Jun 22, 2025, 12_23_42 AM.png",
+    "model": "Google Gemini",
+    "caption": "Here's a detailed and engaging caption, descriptive yet concise:\n\n---\n\n**Harnessing the power of Logistic Regression for vital cancer detection! \ud83d\udcca\ud83e\ude7a**\n\nThis visual beautifully illustrates how this machine learning algorithm classifies data, using the characteristic sigmoid curve to distinguish between different patient outcomes (e.g., healthy vs. diseased). A crucial tool in advancing precision medicine and improving healthcare, empowering medical professionals with data-driven insights.\n\n#LogisticRegression #MachineLearning #AIinHealthcare #CancerDetection #DataScience #HealthcareInnovation #MedicalAI #PredictiveAnalytics"
+  },
+  {
+    "timestamp": "2025-06-29T10:46:27.426996",
+    "image_name": "ChatGPT Image Jun 22, 2025, 12_23_42 AM.png",
+    "model": "GROQ Vision",
+    "caption": "The image presents a visual representation of logistic regression on a cancer dataset, featuring a graph and an illustration of a hospital.\n\n*   **Title**\n    *   The title \"LOGISTIC REGRESSION ON CANCER DATASET\" is prominently displayed at the top of the image in large, dark blue text.\n*   **Graph**\n    *   A line graph is situated to the left of the hospital illustration, showcasing a curved line that increases as it moves from left to right.\n    *   The graph features orange dots on the upper left side, representing one group of data points, and blue X's on the lower right side, representing another group.\n    *   The curved line begins on the lower left side of the graph, gradually rising to intersect with the orange dots and then leveling off as it approaches the upper right side.\n*   **Hospital Illustration**\n    *   A light blue hospital building with a dark blue cross on its roof is depicted on the right side of the image.\n    *   The hospital features a central section with a door and windows, accompanied by two smaller sections on either side.\n*   **Background**\n    *   The background of the image is a pale yellow color.\n\nIn summary, the image effectively illustrates the concept of logistic regression on a cancer dataset through a clear and concise visual representation. The graph and hospital illustration work together to convey the relationship between the data points and the predicted outcomes, making it easier for viewers to understand the concept."
+  },
+  {
+    "timestamp": "2025-06-29T11:03:21.461222",
+    "image_name": "Mistral_AI.png",
+    "model": "OpenAI GPT-4o",
+    "caption": "Mistral AI logo featuring modern pixel art design elements."
+  },
+  {
+    "timestamp": "2025-06-29T11:03:49.005152",
+    "image_name": "ChatGPT Image Jun 29, 2025, 01_58_05 AM.png",
+    "model": "OpenAI GPT-4o",
+    "caption": "Code snippet for asynchronous chat with Google Generative AI."
+  },
+  {
+    "timestamp": "2025-06-29T11:04:36.328163",
+    "image_name": "ChatGPT Image Jun 29, 2025, 01_58_05 AM.png",
+    "model": "Google Gemini",
+    "caption": "Python async code for Gemini Pro AI chat."
+  },
+  {
+    "timestamp": "2025-06-29T11:04:53.452858",
+    "image_name": "ChatGPT Image Jun 29, 2025, 01_58_05 AM.png",
+    "model": "GROQ Vision",
+    "caption": "Python code for an asynchronous chat function using Google's Gemini AI."
+  }
+]

caption_history.py

@@ -0,0 +1,71 @@
+import datetime
+import json
+import os
+from typing import Dict, List, Optional
+from langchain.schema import HumanMessage, AIMessage
+from langchain.memory import ConversationBufferMemory
+
+class CaptionHistory:
+    """
+    Manages caption generation history using Langchain
+    """
+    def __init__(self):
+        self.memory = ConversationBufferMemory(
+            return_messages=True,
+            memory_key="chat_history"
+        )
+        self.history_file = "caption_history.json"
+        self.load_history()  # Load existing history on initialization
+
+    def add_interaction(self, image_name: str, model: str,
+    caption: str, timestamp: str|None = None):
+        if not timestamp:
+            timestamp = datetime.datetime.now().isoformat()
+
+        interaction = {
+            "timestamp": timestamp,
+            "image_name": image_name,
+            "model": model,
+            "caption": caption
+        }
+
+        # Add to langchain memory
+        human_msg = HumanMessage(
+            content=f"Generate caption for {image_name} using {model}"
+        )
+        ai_msg = AIMessage(content=caption)
+
+        self.memory.chat_memory.add_user_message(human_msg.content)
+        self.memory.chat_memory.add_ai_message(ai_msg.content)
+
+        # Save the file 
+        self.save_interaction(interaction)
+
+    def get_history(self) -> List[Optional[Dict[str, str]]]:
+        try:
+            with open(self.history_file, mode="r") as f:
+                return json.load(f)
+        except FileNotFoundError:
+            return []
+
+    def save_interaction(self, interaction: Dict[str, str]) -> None:
+        history = self.get_history()
+        history.append(interaction)
+        with open(self.history_file, mode="w") as f:
+            json.dump(history, f, indent=2)
+
+    def load_history(self):
+        """Fixed: Proper string formatting in f-strings"""
+        history = self.get_history()
+        for item in history:
+            human_msg = HumanMessage(
+                content=f"Generate caption for {item['image_name']} using {item['model']}"  # Fixed: proper quotes
+            )
+            ai_msg = AIMessage(content=item["caption"]) 
+            self.memory.chat_memory.add_user_message(human_msg.content)
+            self.memory.chat_memory.add_ai_message(ai_msg.content)
+
+    def clear_history(self):
+        self.memory.clear()
+        if os.path.exists(self.history_file):
+            os.remove(self.history_file)

caption_overlay.py

@@ -0,0 +1,154 @@
+import os
+import cv2
+import numpy as np
+
+from PIL import Image, ImageDraw, ImageFont
+
+class ImageCaptionOverlay:
+    """Handles adding captions to images using OpenCV"""
+    
+    @staticmethod
+    def add_caption_overlay(image: np.ndarray, caption: str, position: str = "bottom", 
+    font_size: int = 1, thickness: int = 2) -> np.ndarray:
+        """Add caption as overlay on the image"""
+        img_copy = image.copy()
+        height, width = img_copy.shape[:2]
+        
+        # Prepare text
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        
+        # Calculate text size and position
+        text_size = cv2.getTextSize(caption, font, font_size, thickness)[0]
+        
+        # Wrap text if too long
+        max_width = width - 40
+        if text_size[0] > max_width:
+            words = caption.split()
+            lines = []
+            current_line = ""
+            
+            for word in words:
+                test_line = current_line + " " + word if current_line else word
+                test_size = cv2.getTextSize(test_line, font, font_size, thickness)[0]
+                
+                if test_size[0] <= max_width:
+                    current_line = test_line
+                else:
+                    if current_line:
+                        lines.append(current_line)
+                    current_line = word
+            
+            if current_line:
+                lines.append(current_line)
+        else:
+            lines = [caption]
+        
+        # Calculate positions
+        line_height = cv2.getTextSize("A", font, font_size, thickness)[0][1] + 10
+        total_height = len(lines) * line_height
+        
+        if position == "bottom":
+            start_y = height - total_height - 20
+        elif position == "top":
+            start_y = 30
+        else:  # center
+            start_y = (height - total_height) // 2
+        
+        # Add background rectangle for better readability
+        for i, line in enumerate(lines):
+            text_size = cv2.getTextSize(line, font, font_size, thickness)[0]
+            text_x = (width - text_size[0]) // 2
+            text_y = start_y + (i * line_height) + text_size[1]
+            
+            # Background rectangle
+            cv2.rectangle(img_copy, 
+                         (text_x - 10, text_y - text_size[1] - 5),
+                         (text_x + text_size[0] + 10, text_y + 5),
+                         (0, 0, 0), -1)
+            
+            # Text
+            cv2.putText(img_copy, line, (text_x, text_y), font, font_size, (255, 255, 255), thickness)
+        
+        return img_copy
+    
+    @staticmethod
+    def add_caption_background(image: np.ndarray, caption: str, 
+                             font_path: str = None,
+                             background_color: tuple = (0, 0, 0),
+                             text_color: tuple = (255, 255, 255), 
+                             margin: int = 50) -> np.ndarray:
+        """Add caption on a background behind the image"""
+        height, width = image.shape[:2]
+        
+        # Use PIL for better text rendering
+        pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        
+        # Try to use Poppins font first, then fallback to default
+        try:
+            # First priority: custom font path if provided
+            if font_path and os.path.exists(font_path):
+                font = ImageFont.truetype(font_path, 24)
+            # Second priority: check for Poppins font in fonts directory
+            elif os.path.exists("fonts/Poppins-Regular.ttf"):
+                font = ImageFont.truetype("fonts/Poppins-Regular.ttf", 24)
+            else:
+                # Fallback to default font
+                font = ImageFont.load_default()
+        except Exception:
+            # If anything fails, use default font
+            font = ImageFont.load_default()
+        
+        # Calculate text dimensions
+        draw = ImageDraw.Draw(pil_image)
+        bbox = draw.textbbox((0, 0), caption, font=font)
+        text_width = bbox[2] - bbox[0]
+        text_height = bbox[3] - bbox[1]
+        
+        # Wrap text if necessary
+        max_width = width - (2 * margin)
+        if text_width > max_width:
+            words = caption.split()
+            lines = []
+            current_line = ""
+            
+            for word in words:
+                test_line = current_line + " " + word if current_line else word
+                test_bbox = draw.textbbox((0, 0), test_line, font=font)
+                test_width = test_bbox[2] - test_bbox[0]
+                
+                if test_width <= max_width:
+                    current_line = test_line
+                else:
+                    if current_line:
+                        lines.append(current_line)
+                    current_line = word
+            
+            if current_line:
+                lines.append(current_line)
+        else:
+            lines = [caption]
+        
+        # Calculate total text height
+        total_text_height = len(lines) * text_height + (len(lines) - 1) * 10
+        
+        # Create new image with space for text
+        new_height = height + total_text_height + (2 * margin)
+        new_image = Image.new('RGB', (width, new_height), background_color)
+        
+        # Paste original image
+        new_image.paste(pil_image, (0, total_text_height + (2 * margin)))
+        
+        # Add text
+        draw = ImageDraw.Draw(new_image)
+        y_offset = margin
+        
+        for line in lines:
+            bbox = draw.textbbox((0, 0), line, font=font)
+            line_width = bbox[2] - bbox[0]
+            x_position = (width - line_width) // 2
+            
+            draw.text((x_position, y_offset), line, fill=text_color, font=font)
+            y_offset += text_height + 10
+        
+        # Convert back to OpenCV format
+        return cv2.cvtColor(np.array(new_image), cv2.COLOR_RGB2BGR)

main.py

@@ -0,0 +1,294 @@
+from caption_history import CaptionHistory
+from caption_generation import MultiModelCaptionGenerator
+from caption_overlay import ImageCaptionOverlay
+
+import io
+import os
+
+import cv2
+import numpy as np
+from PIL import Image
+import streamlit as st
+from dotenv import load_dotenv
+
+load_dotenv()
+
+openai_key = os.getenv("OPENAI_API_KEY_IC")
+gemini_key = os.getenv("GEMINI_API_KEY_IC")
+groq_key = os.getenv("GROQ_API_KEY_IC")
+
+def main():
+    st.set_page_config(
+        page_title="Multi-Model Image Caption Generator",
+        page_icon="🖼️",
+        layout="wide"
+    )
+    
+    st.title("🖼️ Multi-Model Image Caption Generator")
+    st.markdown("Generate captions using OpenAI GPT-4V, Google Gemini, and GROQ Vision models")
+    
+    # Initialize session state
+    if 'caption_history' not in st.session_state:
+        st.session_state.caption_history = CaptionHistory()
+    
+    if 'caption_generator' not in st.session_state:
+        st.session_state.caption_generator = MultiModelCaptionGenerator()
+    
+    # Sidebar for API configuration
+    with st.sidebar: 
+        st.header("🔑 API Configuration")
+        
+        # Show API status
+        if openai_key:
+            st.success("✅ OpenAI API Key loaded from .env")
+        else:
+            st.warning("⚠️ OpenAI API Key not found in .env")
+            
+        if gemini_key:
+            st.success("✅ Gemini API Key loaded from .env")
+        else:
+            st.warning("⚠️ Gemini API Key not found in .env")
+            
+        if groq_key:
+            st.success("✅ GROQ API Key loaded from .env")
+        else:
+            st.warning("⚠️ GROQ API Key not found in .env")
+        
+        if st.button("Configure APIs"):
+            try:
+                st.session_state.caption_generator.configure_apis(
+                    openai_key=openai_key,
+                    gemini_key=gemini_key,
+                    groq_key=groq_key
+                )
+                st.success("APIs configured successfully!")
+            except Exception as e:
+                st.error(f"Error configuring APIs: {str(e)}")
+        
+        st.markdown("---")
+        
+        # Caption overlay settings
+        st.header("🎨 Caption Settings")
+        caption_method = st.selectbox(
+            "Caption Method",
+            ["Overlay on Image", "Background Behind Image"]
+        )
+        
+        if caption_method == "Overlay on Image":
+            position = st.selectbox("Position", ["bottom", "top", "center"])
+            font_size = st.slider("Font Size", 0.5, 3.0, 1.0, 0.1)
+            thickness = st.slider("Thickness", 1, 5, 2)
+        else:
+            bg_color = st.color_picker("Background Color", "#000000")
+            text_color = st.color_picker("Text Color", "#FFFFFF")
+            margin = st.slider("Margin", 20, 100, 50)
+            
+            # Optional: Custom font path
+            custom_font = st.text_input(
+                "Custom Font Path (optional)", 
+                placeholder="e.g., fonts/Poppins-Regular.ttf"
+            )
+        
+        st.markdown("---")
+        
+        # History management
+        st.header("📝 Caption History")
+        if st.button("View History"):
+            st.session_state.show_history = True
+        
+        if st.button("Hide History"):
+            st.session_state.show_history = False
+        
+        if st.button("Clear History"):
+            st.session_state.caption_history.clear_history()
+            st.success("History cleared!")
+    
+    # Main content area
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.header("📤 Upload Image")
+        uploaded_file = st.file_uploader(
+            "Choose an image...",
+            type=['png', 'jpg', 'jpeg', 'bmp', 'tiff']
+        )
+        
+        if uploaded_file is not None:
+            # Display original image
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Original Image", use_container_width=True)
+            
+            # Model selection
+            st.header("🤖 Select Model")
+            models = {
+                "OpenAI GPT-4o": "openai",      # Updated model name
+                "Google Gemini": "gemini",
+                "GROQ Vision": "groq"
+            }
+            
+            selected_model = st.selectbox("Choose a model", list(models.keys()))
+            
+            # Show model-specific info
+            model_info = {
+                "OpenAI GPT-4o": "Uses GPT-4o vision model for detailed image analysis",
+                "Google Gemini": "Uses Gemini-1.5-flash for fast and accurate captions", 
+                "GROQ Vision": "Uses Llama-3.2-11b-vision for high-speed processing"
+            }
+            st.info(model_info[selected_model])
+            
+            if st.button("Generate Caption", type="primary"):
+                # Check if APIs are configured
+                if not any([openai_key, gemini_key, groq_key]):
+                    st.error("Please add API keys to your .env file and click 'Configure APIs'")
+                    return
+                
+                try:
+                    model_key = models[selected_model]
+                    
+                    # Check specific API availability
+                    if model_key == "openai" and not openai_key:
+                        st.error("OpenAI API key not available. Please add it to your .env file.")
+                        return
+                    elif model_key == "gemini" and not gemini_key:
+                        st.error("Gemini API key not available. Please add it to your .env file.")
+                        return
+                    elif model_key == "groq" and not groq_key:
+                        st.error("GROQ API key not available. Please add it to your .env file.")
+                        return
+                    
+                    with st.spinner(f"Generating caption with {selected_model}..."):
+                        if model_key == "openai":
+                            caption = st.session_state.caption_generator.generate_caption_openai(image)
+                        elif model_key == "gemini":
+                            caption = st.session_state.caption_generator.generate_caption_gemini(image)
+                        elif model_key == "groq":
+                            caption = st.session_state.caption_generator.generate_caption_groq(image)
+                    
+                    st.session_state.current_caption = caption
+                    st.session_state.current_image = image
+                    st.session_state.current_model = selected_model
+                    
+                    # Add to history
+                    st.session_state.caption_history.add_interaction(
+                        uploaded_file.name,
+                        selected_model,
+                        caption
+                    )
+                    
+                    st.success(f"Caption generated successfully with {selected_model}!")
+                    
+                except Exception as e:
+                    st.error(f"Error generating caption: {str(e)}")
+                    st.error("Please check your API keys and internet connection.")
+    
+    with col2:
+        st.header("✨ Generated Caption & Preview")
+        
+        if hasattr(st.session_state, 'current_caption'):
+            # Editable caption
+            edited_caption = st.text_area(
+                "Generated Caption (editable)",
+                st.session_state.current_caption,
+                height=100,
+                help="You can edit the caption before applying it to the image"
+            )
+            
+            # Update the caption if edited
+            if edited_caption != st.session_state.current_caption:
+                st.session_state.current_caption = edited_caption
+            
+            # Generate preview with caption
+            if hasattr(st.session_state, 'current_image'):
+                # Convert PIL to OpenCV format
+                cv_image = cv2.cvtColor(np.array(st.session_state.current_image), cv2.COLOR_RGB2BGR)
+                
+                try:
+                    if caption_method == "Overlay on Image":
+                        result_image = ImageCaptionOverlay.add_caption_overlay(
+                            cv_image,
+                            st.session_state.current_caption,
+                            position=position,
+                            font_size=font_size,
+                            thickness=thickness
+                        )
+                    else:
+                        # Convert hex colors to RGB tuples
+                        bg_rgb = tuple(int(bg_color[i:i+2], 16) for i in (1, 3, 5))
+                        text_rgb = tuple(int(text_color[i:i+2], 16) for i in (1, 3, 5))
+                        
+                        # Use custom font if provided
+                        font_path = custom_font if custom_font and os.path.exists(custom_font) else None
+                        
+                        result_image = ImageCaptionOverlay.add_caption_background(
+                            cv_image,
+                            st.session_state.current_caption,
+                            font_path=font_path,
+                            background_color=bg_rgb,
+                            text_color=text_rgb,
+                            margin=margin
+                        )
+                    
+                    # Convert back to PIL for display
+                    result_pil = Image.fromarray(cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB))
+                    st.image(result_pil, caption="Image with Caption", use_container_width=True)
+                    
+                    # Download button
+                    img_buffer = io.BytesIO()
+                    result_pil.save(img_buffer, format='PNG')
+                    
+                    st.download_button(
+                        label="📥 Download Image with Caption",
+                        data=img_buffer.getvalue(),
+                        file_name=f"captioned_{uploaded_file.name if uploaded_file else 'image'}.png",
+                        mime="image/png"
+                    )
+                    
+                except Exception as e:
+                    st.error(f"Error processing image: {str(e)}")
+        else:
+            st.info("👆 Upload an image and generate a caption to see the preview here")
+    
+    # History display
+    if getattr(st.session_state, 'show_history', False):
+        st.markdown("---")
+        st.header("📋 Caption Generation History")
+        
+        history = st.session_state.caption_history.get_history()
+        
+        if history:
+            # Add search/filter functionality
+            search_term = st.text_input("🔍 Search history", placeholder="Search by image name or caption...")
+            
+            filtered_history = history
+            if search_term:
+                filtered_history = [
+                    item for item in history 
+                    if search_term.lower() in item['image_name'].lower() 
+                    or search_term.lower() in item['caption'].lower()
+                    or search_term.lower() in item['model'].lower()
+                ]
+            
+            if filtered_history:
+                for i, item in enumerate(reversed(filtered_history[-20:])):  # Show last 20 items
+                    with st.expander(f"{item['timestamp'][:19]} - {item['image_name']} ({item['model']})"):
+                        st.write(f"**Model:** {item['model']}")
+                        st.write(f"**Image:** {item['image_name']}")
+                        st.write(f"**Caption:** {item['caption']}")
+                        st.write(f"**Timestamp:** {item['timestamp']}")
+            else:
+                st.info("No matching history found.")
+        else:
+            st.info("No caption history available.")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style='text-align: center'>
+        <p>Built with Streamlit, LangChain, OpenCV, and multi-model AI APIs</p>
+        <p>Supports OpenAI GPT-4o, Google Gemini, and GROQ Vision models</p>
+        <p><small>Make sure to add your API keys to the .env file</small></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,9 @@
-altair
-pandas
+google-generativeai
+groq
+langchain
+python-dotenv 
+openai
+opencv-python
+numpy
+pillow
 streamlit