promptrend 1.0.0__tar.gz

promptrend-1.0.0/LICENSE

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

promptrend-1.0.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: promptrend
+Version: 1.0.0
+Summary: Intent Classification and Contextual Bandit Recommendation System
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi==0.68.0
+Requires-Dist: uvicorn==0.15.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: python-dotenv==0.19.0
+Requires-Dist: sqlalchemy==1.4.23
+Requires-Dist: psycopg2-binary==2.9.1
+Requires-Dist: redis==4.1.0
+Requires-Dist: torch>=2.0.0
+Requires-Dist: transformers==4.11.3
+Requires-Dist: scikit-learn==0.24.2
+Requires-Dist: numpy==1.21.2
+Requires-Dist: pandas==1.3.3
+Requires-Dist: datasets==1.11.0
+Requires-Dist: accelerate>=0.21.0
+Provides-Extra: test
+Requires-Dist: pytest==6.2.5; extra == "test"
+Requires-Dist: httpx==0.18.2; extra == "test"
+Requires-Dist: pytest-asyncio==0.15.1; extra == "test"
+Dynamic: license-file
+
+# PrompTrend: Intelligent Chat Support System
+
+PrompTrend is an advanced chat support system that combines intent classification and contextual bandit algorithms to provide personalized recommendations and responses. The system uses BERT for intent classification and implements a contextual multi-armed bandit approach for dynamic learning from user interactions.
+
+## 🌟 Key Features
+
+- Intent classification using BERT
+- Contextual bandit-based recommendation system
+- Real-time user feedback processing
+- Automatic question generation
+- Redis caching for improved performance
+- Comprehensive API documentation
+- Robust error handling
+- Database persistence with PostgreSQL
+
+## 🛠️ Technology Stack
+
+- **Framework**: FastAPI
+- **ML Models**: BERT (Transformers), T5
+- **Database**: PostgreSQL
+- **Caching**: Redis
+- **ML Libraries**: PyTorch, Scikit-learn
+- **Testing**: Pytest
+- **Documentation**: OpenAPI (Swagger)
+
+## 📋 Prerequisites
+
+- Python 3.8+
+- PostgreSQL
+- Redis
+- CUDA-compatible GPU (optional, for faster model training)
+
+## ⚙️ Installation
+
+You can install PrompTrend directly via pip (once published):
+```bash
+pip install promptrend
+```
+
+For development, clone the repository and install in editable mode:
+```bash
+git clone https://github.com/yourusername/promptrend.git
+cd promptrend
+pip install -e .[test]
+```
+
+Set up environment variables:
+```bash
+python scripts/setup_env.py --env development
+```
+
+## 🚀 Running the Application
+
+1. Start the Redis server:
+```bash
+redis-server
+```
+
+2. Start the application using the CLI:
+```bash
+promptrend-server
+```
+
+The API will be available at `http://localhost:8000`
+
+## 📚 API Documentation
+
+Once the application is running, you can access the interactive API documentation at:
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`
+
+## 🧪 Testing
+
+The project includes comprehensive tests for all components. To run the tests:
+
+```bash
+# Run all tests
+pytest
+
+# Run tests with coverage report
+pytest --cov=app tests/
+
+# Run specific test file
+pytest tests/test_intent_classifier.py
+```
+
+## 📂 Project Structure
+
+```
+promptrend/
+├── api/
+│   └── routes.py          # API endpoints
+├── core/
+│   ├── config.py          # Configuration management
+│   ├── database.py        # Database setup
+│   ├── models.py          # Data models
+│   └── cache.py           # Redis cache implementation
+├── services/
+│   ├── intent_classifier.py    # BERT classifier
+│   ├── recommender.py          # Contextual bandit
+│   ├── recommendation_service.py
+│   ├── question_generator.py   # T5 question generator
+│   └── error_handler.py        # Error handling service
+├── tests/
+│   ├── test_intent_classifier.py
+│   ├── test_recommender.py
+│   ├── test_api.py
+│   └── test_integration.py 
+├── scripts/
+│   └── setup_env.py
+├── main.py
+├── requirements.txt
+└── README.md
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Hugging Face for the Transformers library
+- FastAPI team for the amazing framework
+- The open-source community for various dependencies
+
+## 📞 Contact
+
+For questions and feedback, please create an issue in the GitHub repository.

promptrend-1.0.0/README.md

@@ -0,0 +1,136 @@
+# PrompTrend: Intelligent Chat Support System
+
+PrompTrend is an advanced chat support system that combines intent classification and contextual bandit algorithms to provide personalized recommendations and responses. The system uses BERT for intent classification and implements a contextual multi-armed bandit approach for dynamic learning from user interactions.
+
+## 🌟 Key Features
+
+- Intent classification using BERT
+- Contextual bandit-based recommendation system
+- Real-time user feedback processing
+- Automatic question generation
+- Redis caching for improved performance
+- Comprehensive API documentation
+- Robust error handling
+- Database persistence with PostgreSQL
+
+## 🛠️ Technology Stack
+
+- **Framework**: FastAPI
+- **ML Models**: BERT (Transformers), T5
+- **Database**: PostgreSQL
+- **Caching**: Redis
+- **ML Libraries**: PyTorch, Scikit-learn
+- **Testing**: Pytest
+- **Documentation**: OpenAPI (Swagger)
+
+## 📋 Prerequisites
+
+- Python 3.8+
+- PostgreSQL
+- Redis
+- CUDA-compatible GPU (optional, for faster model training)
+
+## ⚙️ Installation
+
+You can install PrompTrend directly via pip (once published):
+```bash
+pip install promptrend
+```
+
+For development, clone the repository and install in editable mode:
+```bash
+git clone https://github.com/yourusername/promptrend.git
+cd promptrend
+pip install -e .[test]
+```
+
+Set up environment variables:
+```bash
+python scripts/setup_env.py --env development
+```
+
+## 🚀 Running the Application
+
+1. Start the Redis server:
+```bash
+redis-server
+```
+
+2. Start the application using the CLI:
+```bash
+promptrend-server
+```
+
+The API will be available at `http://localhost:8000`
+
+## 📚 API Documentation
+
+Once the application is running, you can access the interactive API documentation at:
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`
+
+## 🧪 Testing
+
+The project includes comprehensive tests for all components. To run the tests:
+
+```bash
+# Run all tests
+pytest
+
+# Run tests with coverage report
+pytest --cov=app tests/
+
+# Run specific test file
+pytest tests/test_intent_classifier.py
+```
+
+## 📂 Project Structure
+
+```
+promptrend/
+├── api/
+│   └── routes.py          # API endpoints
+├── core/
+│   ├── config.py          # Configuration management
+│   ├── database.py        # Database setup
+│   ├── models.py          # Data models
+│   └── cache.py           # Redis cache implementation
+├── services/
+│   ├── intent_classifier.py    # BERT classifier
+│   ├── recommender.py          # Contextual bandit
+│   ├── recommendation_service.py
+│   ├── question_generator.py   # T5 question generator
+│   └── error_handler.py        # Error handling service
+├── tests/
+│   ├── test_intent_classifier.py
+│   ├── test_recommender.py
+│   ├── test_api.py
+│   └── test_integration.py 
+├── scripts/
+│   └── setup_env.py
+├── main.py
+├── requirements.txt
+└── README.md
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Hugging Face for the Transformers library
+- FastAPI team for the amazing framework
+- The open-source community for various dependencies
+
+## 📞 Contact
+
+For questions and feedback, please create an issue in the GitHub repository.

promptrend-1.0.0/promptrend/__init__.py

@@ -0,0 +1,6 @@
+from .services.intent_classifier import IntentClassifier
+from .services.recommender import ContextualBandit as Recommender
+from .services.question_generator import QuestionGenerator
+
+__version__ = "1.0.0"
+__all__ = ["IntentClassifier", "Recommender", "QuestionGenerator"]

promptrend-1.0.0/promptrend/api/routes.py

@@ -0,0 +1,167 @@
+from fastapi import APIRouter, HTTPException, BackgroundTasks, Depends
+from typing import List, Optional
+from promptrend.core.models import (
+    RecommendationRequest,
+    RecommendationResponse,
+    TrainingRequest,
+    TrainingResponse,
+    IntentClassifierConfig,
+    FeedbackRequest,
+    FeedbackResponse
+)
+from promptrend.services.intent_classifier import IntentClassifier
+from promptrend.services.recommender import ContextualBandit
+from promptrend.services.recommendation_service import RecommendationService
+from sqlalchemy.orm import Session
+from promptrend.core.database import get_db
+import logging
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# Create router
+router = APIRouter()
+
+# Initialize services
+intent_classifier = None
+bandit = ContextualBandit()
+recommendation_service = RecommendationService()
+
+@router.post("/initialize", response_model=dict)
+async def initialize_classifier(config: IntentClassifierConfig):
+    """Initialize or load the intent classifier"""
+    global intent_classifier
+    try:
+        logger.info(f"Initializing classifier with config: {config}")
+        intent_classifier = IntentClassifier(
+            model_path=config.model_path,
+            num_labels=config.num_labels,
+            use_pretrained=config.use_pretrained
+        )
+        return {"status": "success", "message": "Classifier initialized"}
+    except Exception as e:
+        logger.error(f"Failed to initialize classifier: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/feedback", response_model=FeedbackResponse)
+async def store_feedback(
+    request: FeedbackRequest,
+    db: Session = Depends(get_db)
+):
+    """Store and process user feedback for recommendations"""
+    try:
+        logger.info(f"Storing feedback for user {request.user_id}, recommendation {request.recommendation_id}")
+        await recommendation_service.store_feedback(
+            db=db,
+            user_id=request.user_id,
+            recommendation_id=request.recommendation_id,
+            feedback_score=request.feedback_score
+        )
+        return FeedbackResponse(status="success", message="Feedback stored successfully")
+    except Exception as e:
+        logger.error(f"Failed to store feedback: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/train", response_model=TrainingResponse)
+async def train_classifier(request: TrainingRequest, background_tasks: BackgroundTasks):
+    """Train the classifier with new data"""
+    global intent_classifier
+    
+    if not request.training_data:
+        raise HTTPException(status_code=400, detail="Training data cannot be empty")
+    
+    if intent_classifier is None:
+        raise HTTPException(status_code=400, detail="Classifier not initialized")
+    
+    # Validate training data before queuing
+    labels = [item.label for item in request.training_data]
+    num_labels = intent_classifier.model.config.num_labels
+    if any(label < 0 or label >= num_labels for label in labels):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Labels must be between 0 and {num_labels - 1}"
+        )
+    
+    try:
+        logger.info(f"Starting training with {len(request.training_data)} examples for {request.epochs} epochs")
+        # Convert training data to the format expected by IntentClassifier
+        formatted_training_data = [
+            {"text": item.text, "label": item.label}
+            for item in request.training_data
+        ]
+        
+        background_tasks.add_task(
+            intent_classifier.train,
+            formatted_training_data,
+            request.epochs
+        )
+        return TrainingResponse(status="success", message="Training started in background")
+    except Exception as e:
+        logger.error(f"Failed to train classifier: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/recommendations", response_model=RecommendationResponse)
+async def get_recommendations(request: RecommendationRequest, db: Session = Depends(get_db)):
+    """Get recommendations based on chat history and generate relevant questions"""
+    global intent_classifier
+    
+    if not request.chat_history.messages:
+        raise HTTPException(
+            status_code=400, 
+            detail="Chat history cannot be empty"
+        )
+    
+    if intent_classifier is None:
+        raise HTTPException(status_code=400, detail="Classifier not initialized")
+        
+    try:
+        logger.info(f"Getting recommendations for user {request.user_id}")
+        
+        # Classify intents
+        intents_and_scores = [
+            intent_classifier.classify(msg.content)
+            for msg in request.chat_history.messages
+        ]
+        
+        intents, confidence_scores = zip(*intents_and_scores)
+        
+        # Get context vector
+        context = bandit.get_context_vector(
+            request.user_id,
+            [msg.content for msg in request.chat_history.messages],
+            list(confidence_scores)
+        )
+        
+        # Use default categories if none provided
+        categories = request.categories or ["general", "technical", "support"]
+        
+        # Get recommendations from service
+        result = await recommendation_service.get_recommendations(
+            db=db,
+            user_id=request.user_id,
+            chat_history=[msg.dict() for msg in request.chat_history.messages],
+            categories=categories,
+            num_recommendations=request.num_recommendations
+        )
+        
+        # Generate questions using the question generator
+        from promptrend.services.question_generator import QuestionGenerator
+        question_generator = QuestionGenerator()
+        generated_questions = question_generator.generate_questions(
+            result["recommendations"],
+            [msg.content for msg in request.chat_history.messages],
+            num_questions=request.num_recommendations
+        )
+        
+        # Add recommendation_ids to result if not present
+        if "recommendation_ids" not in result:
+            result["recommendation_ids"] = []
+        
+        # Include generated questions in response
+        result["generated_questions"] = generated_questions
+        
+        return RecommendationResponse(**result)
+        
+    except Exception as e:
+        logger.error(f"Failed to get recommendations: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

promptrend-1.0.0/promptrend/app.py

@@ -0,0 +1,65 @@
+from fastapi import FastAPI
+from promptrend.api.routes import router as api_router  # Note the import alias
+from promptrend.core.config import get_settings
+from promptrend.core.database import init_db
+import logging
+import os
+
+# Configure logging
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # Suppress TF logging
+logging.getLogger('tensorflow').setLevel(logging.ERROR)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Get app settings
+settings = get_settings()
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="PrompTrend API",
+    description="Intent Classification and Contextual Bandit Recommendation System",
+    version="1.0.0",
+)
+
+# Setup middleware for exception handling
+from fastapi import Request
+from fastapi.responses import JSONResponse
+from promptrend.services.error_handler import PrompTrendError, handle_error
+
+@app.middleware("http")
+async def handle_exceptions(request: Request, call_next):
+    try:
+        return await call_next(request)
+    except ValueError as e:
+        return JSONResponse(
+            status_code=400,
+            content={"detail": str(e)}
+        )
+    except PrompTrendError as e:
+        return handle_error(e)
+    except Exception as e:
+        logger.error(f"Unhandled exception: {str(e)}")
+        return JSONResponse(
+            status_code=500,
+            content={"detail": str(e)}
+        )
+
+# Include API router with proper prefix
+app.include_router(api_router, prefix=settings.API_V1_STR)
+
+# Initialize database
+@app.on_event("startup")
+def startup_event():
+    try:
+        logger.info("Initializing database...")
+        init_db()
+        logger.info("Database initialized successfully")
+    except Exception as e:
+        logger.error(f"Failed to initialize database: {str(e)}")
+
+def start():
+    import uvicorn
+    uvicorn.run("promptrend.app:app", host="0.0.0.0", port=8000, reload=True)
+
+if __name__ == "__main__":
+    start()

promptrend-1.0.0/promptrend/core/cache.py

@@ -0,0 +1,65 @@
+# core/cache.py
+import redis
+from typing import Optional, Any, Dict
+import json
+import os
+from functools import wraps
+
+class RedisCache:
+    def __init__(self):
+        self.redis_url = os.getenv("REDIS_URL", "redis://localhost:6379/0")
+        self.redis_client = redis.from_url(self.redis_url)
+        self.default_ttl = 3600  # 1 hour default TTL
+
+    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
+        """Set a value in cache with optional TTL"""
+        try:
+            serialized_value = json.dumps(value)
+            return self.redis_client.set(
+                key,
+                serialized_value,
+                ex=ttl or self.default_ttl
+            )
+        except Exception as e:
+            print(f"Cache set error: {str(e)}")
+            return False
+
+    def get(self, key: str) -> Optional[Any]:
+        """Get a value from cache"""
+        try:
+            value = self.redis_client.get(key)
+            return json.loads(value) if value else None
+        except Exception as e:
+            print(f"Cache get error: {str(e)}")
+            return None
+
+    def delete(self, key: str) -> bool:
+        """Delete a value from cache"""
+        try:
+            return bool(self.redis_client.delete(key))
+        except Exception as e:
+            print(f"Cache delete error: {str(e)}")
+            return False
+
+# Cache decorator
+def cached(ttl: Optional[int] = None):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            cache = RedisCache()
+            
+            # Create cache key from function name and arguments
+            cache_key = f"{func.__name__}:{str(args)}:{str(kwargs)}"
+            
+            # Try to get from cache
+            cached_result = cache.get(cache_key)
+            if cached_result is not None:
+                return cached_result
+            
+            # If not in cache, execute function and cache result
+            result = await func(*args, **kwargs)
+            cache.set(cache_key, result, ttl)
+            return result
+            
+        return wrapper
+    return decorator

promptrend-1.0.0/promptrend/core/config.py

@@ -0,0 +1,42 @@
+# core/config.py
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+from typing import Optional
+import os
+from dotenv import load_dotenv
+
+# Load .env file
+load_dotenv()
+
+class Settings(BaseSettings):
+    # Database
+    DATABASE_URL: str = os.getenv("DATABASE_URL", "postgresql://postgres:postgres@localhost:5432/promptrend")
+    
+    # Redis
+    REDIS_URL: str = os.getenv("REDIS_URL", "redis://localhost:6379/0")
+    REDIS_TTL: int = 3600  # Cache TTL in seconds
+    
+    # Model
+    MODEL_PATH: str = os.getenv("MODEL_PATH", "bert-base-uncased")
+    NUM_LABELS: int = 10
+    USE_PRETRAINED: bool = True
+    
+    # API
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "PrompTrend"
+    
+    # Environment
+    ENVIRONMENT: str = os.getenv("ENVIRONMENT", "development")
+    DEBUG: bool = ENVIRONMENT == "development"
+    
+    # Logging
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+@lru_cache()
+def get_settings() -> Settings:
+    """Get cached settings"""
+    return Settings()