banko-ai-assistant 1.0.0__py3-none-any.whl

banko_ai/cli.py

@@ -0,0 +1,374 @@
+"""
+Command-line interface for Banko AI Assistant.
+
+This module provides CLI commands for running the application and managing data.
+"""
+
+import click
+import os
+from .config.settings import get_config
+from .vector_search.generator import EnhancedExpenseGenerator
+from .web.app import create_app
+
+
+@click.group()
+def cli():
+    """Banko AI Assistant - AI-powered expense analysis and RAG system."""
+    pass
+
+
+@cli.command()
+@click.option('--host', default='0.0.0.0', help='Host to bind to')
+@click.option('--port', default=5000, help='Port to bind to')
+@click.option('--debug', is_flag=True, help='Enable debug mode')
+@click.option('--generate-data', type=int, default=5000, help='Generate sample data before starting (default: 5000 records)')
+@click.option('--no-data', is_flag=True, help='Skip data generation and start with empty database')
+@click.option('--clear-data', is_flag=True, help='Clear existing data before generating new data')
+@click.option('--background', is_flag=True, help='Run in background mode (suppress Flask output)')
+def run(host, port, debug, generate_data, no_data, clear_data, background):
+    """Run the Banko AI Assistant web application."""
+    # Show beautiful startup banner
+    click.echo("🏦 === Banko AI Assistant Starting === 🏦")
+    
+    # Load configuration and show AI service info
+    config = get_config()
+    ai_service = config.ai_service.upper()
+    click.echo(f"🤖 AI Service: {config.ai_service}")
+    
+    # Check AI provider availability
+    try:
+        from .ai_providers.factory import AIProviderFactory
+        ai_config = config.get_ai_config()
+        ai_provider = AIProviderFactory.create_provider(
+            config.ai_service, 
+            ai_config[config.ai_service]
+        )
+        
+        # Test connection and show status
+        if ai_provider.test_connection():
+            click.echo(f"🔧 {ai_service} Available: True")
+            click.echo(f"✅ Active AI Service: {ai_service}")
+        else:
+            click.echo(f"🔧 {ai_service} Available: False")
+            click.echo(f"⚠️  {ai_service} running in demo mode")
+    except Exception as e:
+        click.echo(f"🔧 {ai_service} Available: False")
+        click.echo(f"⚠️  {ai_service} running in demo mode")
+    
+    click.echo("=" * 44)
+    
+    # Generate data if not explicitly disabled
+    if not no_data:
+        click.echo("🔍 Checking database setup...")
+        click.echo(f"Generating {generate_data} sample expense records...")
+        generator = EnhancedExpenseGenerator(config.database_url)
+        
+        # Check if data already exists
+        try:
+            existing_count = generator.get_expense_count()
+            if existing_count > 0 and not clear_data:
+                click.echo(f"✅ Database already contains {existing_count} expense records")
+            else:
+                if clear_data:
+                    click.echo("Clearing existing data...")
+                    generator.clear_expenses()
+                
+                generator.generate_and_save(generate_data)
+                click.echo(f"✅ Successfully generated {generate_data} expense records")
+        except Exception as e:
+            click.echo(f"❌ Error generating data: {e}")
+            return
+    else:
+        click.echo("Skipping data generation (--no-data flag used)")
+    
+    # Show startup completion message
+    click.echo(f"🚀 Starting server on http://localhost:{port}")
+    click.echo("🎉 Banko AI is ready to help with your finances!")
+    click.echo("=" * 44)
+    
+    # Create and run the app
+    app = create_app()
+    
+    if background:
+        # Background mode - suppress Flask output
+        import logging
+        log = logging.getLogger('werkzeug')
+        log.setLevel(logging.ERROR)
+        
+        # Show final message for background mode
+        click.echo(f"🚀 Banko AI running in background on http://localhost:{port}")
+        click.echo("💡 Use 'banko-ai status' to check if it's running")
+        click.echo("🛑 Use 'pkill -f banko-ai' to stop the background process")
+    
+    app.run(host=host, port=port, debug=debug)
+
+
+@cli.command()
+@click.option('--count', default=1000, help='Number of records to generate')
+@click.option('--user-id', help='User ID for generated records')
+@click.option('--clear', is_flag=True, help='Clear existing data before generating')
+def generate_data(count, user_id, clear):
+    """Generate sample expense data."""
+    config = get_config()
+    generator = EnhancedExpenseGenerator(config.database_url)
+    
+    click.echo(f"Generating {count} expense records...")
+    
+    generated_count = generator.generate_and_save(
+        count=count,
+        user_id=user_id,
+        clear_existing=clear
+    )
+    
+    click.echo(f"Successfully generated {generated_count} expense records")
+
+
+@cli.command()
+def clear_data():
+    """Clear all expense data."""
+    config = get_config()
+    generator = EnhancedExpenseGenerator(config.database_url)
+    
+    if generator.clear_expenses():
+        click.echo("Successfully cleared all expense data")
+    else:
+        click.echo("Failed to clear expense data")
+
+
+@cli.command()
+def status():
+    """Show application status."""
+    config = get_config()
+    generator = EnhancedExpenseGenerator(config.database_url)
+    
+    # Check database connection
+    try:
+        count = generator.get_expense_count()
+        click.echo(f"✅ Database connected - {count} expense records")
+    except Exception as e:
+        click.echo(f"❌ Database error: {e}")
+        return
+    
+    # Check AI provider
+    try:
+        from .ai_providers.factory import AIProviderFactory
+        ai_config = config.get_ai_config()
+        ai_provider = AIProviderFactory.create_provider(
+            config.ai_service, 
+            ai_config[config.ai_service]
+        )
+        
+        if ai_provider.test_connection():
+            click.echo(f"✅ AI provider ({config.ai_service}) connected")
+        else:
+            click.echo(f"❌ AI provider ({config.ai_service}) disconnected")
+    except Exception as e:
+        click.echo(f"❌ AI provider error: {e}")
+
+
+@cli.command()
+@click.option('--host', default='0.0.0.0', help='Host to bind to')
+@click.option('--port', default=5000, help='Port to bind to')
+@click.option('--generate-data', type=int, default=5000, help='Generate sample data before starting (default: 5000 records)')
+@click.option('--no-data', is_flag=True, help='Skip data generation and start with empty database')
+@click.option('--clear-data', is_flag=True, help='Clear existing data before generating new data')
+def start(host, port, generate_data, no_data, clear_data):
+    """Start Banko AI in background mode (equivalent to 'run --background')."""
+    # Show beautiful startup banner
+    click.echo("🏦 === Banko AI Assistant Starting === 🏦")
+    
+    # Load configuration and show AI service info
+    config = get_config()
+    ai_service = config.ai_service.upper()
+    click.echo(f"🤖 AI Service: {config.ai_service}")
+    
+    # Check AI provider availability
+    try:
+        from .ai_providers.factory import AIProviderFactory
+        ai_config = config.get_ai_config()
+        ai_provider = AIProviderFactory.create_provider(
+            config.ai_service, 
+            ai_config[config.ai_service]
+        )
+        
+        # Test connection and show status
+        if ai_provider.test_connection():
+            click.echo(f"🔧 {ai_service} Available: True")
+            click.echo(f"✅ Active AI Service: {ai_service}")
+        else:
+            click.echo(f"🔧 {ai_service} Available: False")
+            click.echo(f"⚠️  {ai_service} running in demo mode")
+    except Exception as e:
+        click.echo(f"🔧 {ai_service} Available: False")
+        click.echo(f"⚠️  {ai_service} running in demo mode")
+    
+    click.echo("=" * 44)
+    
+    # Generate data if not explicitly disabled
+    if not no_data:
+        click.echo("🔍 Checking database setup...")
+        click.echo(f"Generating {generate_data} sample expense records...")
+        generator = EnhancedExpenseGenerator(config.database_url)
+        
+        # Check if data already exists
+        try:
+            existing_count = generator.get_expense_count()
+            if existing_count > 0 and not clear_data:
+                click.echo(f"✅ Database already contains {existing_count} expense records")
+            else:
+                if clear_data:
+                    click.echo("Clearing existing data...")
+                    generator.clear_expenses()
+                
+                generator.generate_and_save(generate_data)
+                click.echo(f"✅ Successfully generated {generate_data} expense records")
+        except Exception as e:
+            click.echo(f"❌ Error generating data: {e}")
+            return
+    else:
+        click.echo("Skipping data generation (--no-data flag used)")
+    
+    # Show startup completion message
+    click.echo(f"🚀 Starting server on http://localhost:{port}")
+    click.echo("🎉 Banko AI is ready to help with your finances!")
+    click.echo("=" * 44)
+    
+    # Create and run the app in background mode
+    app = create_app()
+    
+    # Background mode - suppress Flask output
+    import logging
+    log = logging.getLogger('werkzeug')
+    log.setLevel(logging.ERROR)
+    
+    # Show final message for background mode
+    click.echo(f"🚀 Banko AI running in background on http://localhost:{port}")
+    click.echo("💡 Use 'banko-ai status' to check if it's running")
+    click.echo("🛑 Use 'pkill -f banko-ai' to stop the background process")
+    
+    app.run(host=host, port=port, debug=False)
+
+
+@cli.command()
+def help():
+    """Show detailed help and setup instructions."""
+    click.echo("""
+🤖 Banko AI Assistant - Setup Guide
+====================================
+
+This is a modern AI-powered expense analysis application with RAG capabilities.
+
+QUICK START:
+-----------
+1. Set up your environment variables:
+   export AI_SERVICE="watsonx"  # or "openai", "aws", "gemini"
+   export DATABASE_URL="postgresql://root@localhost:26257/banko_ai?sslmode=disable"
+
+2. Configure your AI provider:
+
+   For Watsonx (IBM):
+   export WATSONX_API_KEY="your_api_key_here"
+   export WATSONX_PROJECT_ID="your_project_id_here"
+   export WATSONX_MODEL="meta-llama/llama-2-70b-chat"
+
+   For OpenAI:
+   export OPENAI_API_KEY="your_api_key_here"
+   export OPENAI_MODEL="gpt-3.5-turbo"
+
+   For AWS Bedrock:
+   export AWS_ACCESS_KEY_ID="your_access_key"
+   export AWS_SECRET_ACCESS_KEY="your_secret_key"
+   export AWS_REGION="us-east-1"
+   export AWS_MODEL="anthropic.claude-3-sonnet-20240229-v1:0"
+
+   For Google Gemini:
+   export GOOGLE_APPLICATION_CREDENTIALS="path/to/service-account.json"
+   export GOOGLE_MODEL="gemini-1.5-pro"
+
+3. Start the application:
+   banko-ai run                    # Normal mode with full output
+   banko-ai start                  # Background mode (quiet) - same as run --background
+   banko-ai run --background       # Background mode (quiet)
+   banko-ai run --no-data          # Skip data generation
+   banko-ai run --debug            # Enable debug mode
+
+COMMANDS:
+---------
+  run              Run the web application (normal mode)
+  start            Start the web application (background mode)
+  generate-data    Generate sample expense data
+  clear-data       Clear all expense data
+  status           Show application status
+  search           Search expenses using vector similarity
+  help             Show this help message
+
+FEATURES:
+---------
+✅ Multi-AI Provider Support (OpenAI, AWS Bedrock, IBM Watsonx, Google Gemini)
+✅ Dynamic Model Switching (switch models without restart)
+✅ User Authentication & User-Specific Vector Indexing
+✅ Enhanced Vector Search with Data Enrichment
+✅ Modern PyPI-Ready Package Structure
+✅ Real-time Chat Interface
+✅ Expense Analysis & Categorization
+✅ Multi-language Support
+
+ENDPOINTS:
+----------
+Web Interface: http://localhost:5000
+API Health: http://localhost:5000/api/health
+AI Providers: http://localhost:5000/api/ai-providers
+Models: http://localhost:5000/api/models
+Search: POST http://localhost:5000/api/search (JSON: {"query": "your search", "limit": 10})
+RAG: POST http://localhost:5000/api/rag (JSON: {"query": "your question", "limit": 5})
+
+TROUBLESHOOTING:
+---------------
+- Database connection issues: Check DATABASE_URL
+- AI provider errors: Verify API keys and configuration
+- Model switching: Use the Settings tab in the web interface
+- Vector search: Ensure database has expense data
+
+For more information, visit: https://github.com/your-repo/banko-ai-assistant
+""")
+
+
+@cli.command()
+@click.argument('query')
+@click.option('--user-id', help='User ID to filter results')
+@click.option('--limit', default=10, help='Maximum number of results')
+def search(query, user_id, limit):
+    """Search expenses using vector similarity."""
+    config = get_config()
+    from .vector_search.search import VectorSearchEngine
+    
+    search_engine = VectorSearchEngine(config.database_url)
+    results = search_engine.search_expenses(
+        query=query,
+        user_id=user_id,
+        limit=limit
+    )
+    
+    if not results:
+        click.echo("No results found")
+        return
+    
+    click.echo(f"Found {len(results)} results for '{query}':")
+    click.echo()
+    
+    for i, result in enumerate(results, 1):
+        click.echo(f"{i}. {result.description}")
+        click.echo(f"   Merchant: {result.merchant}")
+        click.echo(f"   Amount: ${result.amount:.2f}")
+        click.echo(f"   Date: {result.date}")
+        click.echo(f"   Similarity: {result.similarity_score:.3f}")
+        click.echo()
+
+
+def main():
+    """Main CLI entry point."""
+    cli()
+
+
+if __name__ == '__main__':
+    main()

banko_ai/config/__init__.py

@@ -0,0 +1,5 @@
+"""Configuration management for Banko AI Assistant."""
+
+from .settings import Config, get_config
+
+__all__ = ["Config", "get_config"]

banko_ai/config/settings.py

@@ -0,0 +1,216 @@
+"""
+Configuration management using environment variables.
+
+This module provides a centralized configuration system that reads from environment
+variables with sensible defaults, making the application easy to configure and deploy.
+"""
+
+import os
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass
+
+
+@dataclass
+class Config:
+    """Application configuration loaded from environment variables."""
+    
+    # Database Configuration
+    database_url: str
+    database_host: str = "localhost"
+    database_port: int = 26257
+    database_name: str = "defaultdb"
+    database_user: str = "root"
+    database_password: str = ""
+    ssl_mode: str = "disable"
+    
+    # AI Service Configuration
+    ai_service: str = "watsonx"  # openai, aws, watsonx, gemini
+    openai_api_key: Optional[str] = None
+    openai_model: str = "gpt-3.5-turbo"  # gpt-3.5-turbo, gpt-4, gpt-4-turbo
+    aws_access_key_id: Optional[str] = None
+    aws_secret_access_key: Optional[str] = None
+    aws_region: str = "us-east-1"
+    aws_model: str = "us.anthropic.claude-3-5-sonnet-20241022-v2:0"  # Claude models
+    watsonx_api_key: Optional[str] = None
+    watsonx_project_id: Optional[str] = None
+    watsonx_model: str = "openai/gpt-oss-120b"  # IBM models
+    google_project_id: Optional[str] = None
+    google_location: str = "us-central1"
+    google_model: str = "gemini-1.5-pro"  # Gemini models
+    
+    # Application Configuration
+    secret_key: str = "your-secret-key-change-in-production"
+    debug: bool = False
+    host: str = "0.0.0.0"
+    port: int = 5000
+    
+    # Vector Search Configuration
+    embedding_model: str = "all-MiniLM-L6-v2"
+    vector_dimensions: int = 384
+    similarity_threshold: float = 0.7
+    
+    # Cache Configuration
+    cache_enabled: bool = True
+    cache_ttl: int = 3600  # 1 hour
+    
+    # Data Generation Configuration
+    default_record_count: int = 10000
+    default_user_count: int = 100
+    
+    @classmethod
+    def from_env(cls) -> "Config":
+        """Create configuration from environment variables."""
+        # Database configuration
+        database_url = os.getenv("DATABASE_URL", "cockroachdb://root@localhost:26257/banko_ai?sslmode=disable")
+        
+        # Parse database URL for individual components
+        db_host = os.getenv("DATABASE_HOST", "localhost")
+        db_port = int(os.getenv("DATABASE_PORT", "26257"))
+        db_name = os.getenv("DATABASE_NAME", "banko_ai")
+        db_user = os.getenv("DATABASE_USER", "root")
+        db_password = os.getenv("DATABASE_PASSWORD", "")
+        ssl_mode = os.getenv("DATABASE_SSL_MODE", "disable")
+        
+        # AI Service configuration
+        ai_service = os.getenv("AI_SERVICE", "watsonx").lower()
+        
+        return cls(
+            # Database
+            database_url=database_url,
+            database_host=db_host,
+            database_port=db_port,
+            database_name=db_name,
+            database_user=db_user,
+            database_password=db_password,
+            ssl_mode=ssl_mode,
+            
+            # AI Services
+            ai_service=ai_service,
+            openai_api_key=os.getenv("OPENAI_API_KEY"),
+            openai_model=os.getenv("OPENAI_MODEL", "gpt-3.5-turbo"),
+            aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+            aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+            aws_region=os.getenv("AWS_REGION", "us-east-1"),
+            aws_model=os.getenv("AWS_MODEL", "us.anthropic.claude-3-5-sonnet-20241022-v2:0"),
+            watsonx_api_key=os.getenv("WATSONX_API_KEY"),
+            watsonx_project_id=os.getenv("WATSONX_PROJECT_ID"),
+            watsonx_model=os.getenv("WATSONX_MODEL", "openai/gpt-oss-120b"),
+            google_project_id=os.getenv("GOOGLE_PROJECT_ID"),
+            google_location=os.getenv("GOOGLE_LOCATION", "us-central1"),
+            google_model=os.getenv("GOOGLE_MODEL", "gemini-1.5-pro"),
+            
+            # Application
+            secret_key=os.getenv("SECRET_KEY", "your-secret-key-change-in-production"),
+            debug=os.getenv("DEBUG", "false").lower() == "true",
+            host=os.getenv("HOST", "0.0.0.0"),
+            port=int(os.getenv("PORT", "5000")),
+            
+            # Vector Search
+            embedding_model=os.getenv("EMBEDDING_MODEL", "all-MiniLM-L6-v2"),
+            vector_dimensions=int(os.getenv("VECTOR_DIMENSIONS", "384")),
+            similarity_threshold=float(os.getenv("SIMILARITY_THRESHOLD", "0.7")),
+            
+            # Cache
+            cache_enabled=os.getenv("CACHE_ENABLED", "true").lower() == "true",
+            cache_ttl=int(os.getenv("CACHE_TTL", "3600")),
+            
+            # Data Generation
+            default_record_count=int(os.getenv("DEFAULT_RECORD_COUNT", "10000")),
+            default_user_count=int(os.getenv("DEFAULT_USER_COUNT", "100")),
+        )
+    
+    def get_ai_config(self) -> Dict[str, Any]:
+        """Get AI service specific configuration."""
+        config = {
+            "service": self.ai_service,
+            "openai": {
+                "api_key": self.openai_api_key,
+                "model": self.openai_model,
+            },
+            "aws": {
+                "access_key_id": self.aws_access_key_id,
+                "secret_access_key": self.aws_secret_access_key,
+                "region": self.aws_region,
+                "model": self.aws_model,
+            },
+            "watsonx": {
+                "api_key": self.watsonx_api_key,
+                "project_id": self.watsonx_project_id,
+                "model": self.watsonx_model,
+            },
+            "gemini": {
+                "project_id": self.google_project_id,
+                "location": self.google_location,
+                "model": self.google_model,
+            }
+        }
+        return config
+    
+    def get_available_models(self) -> Dict[str, List[str]]:
+        """Get available models for each AI provider."""
+        return {
+            "openai": [
+                "gpt-3.5-turbo",
+                "gpt-3.5-turbo-16k", 
+                "gpt-4",
+                "gpt-4-turbo",
+                "gpt-4o",
+                "gpt-4o-mini"
+            ],
+            "aws": [
+                "us.anthropic.claude-3-5-sonnet-20241022-v2:0",
+                "us.anthropic.claude-3-5-haiku-20241022-v1:0",
+                "us.anthropic.claude-3-opus-20240229-v1:0",
+                "us.anthropic.claude-3-sonnet-20240229-v1:0",
+                "us.anthropic.claude-3-haiku-20240307-v1:0"
+            ],
+            "watsonx": [
+                "openai/gpt-oss-120b",
+                "ibm/granite-13b-chat-v2",
+                "ibm/granite-13b-instruct-v2",
+                "ibm/granite-8b-chat-v2",
+                "ibm/granite-8b-instruct-v2",
+                "meta-llama/llama-2-70b-chat",
+                "meta-llama/llama-2-13b-chat"
+            ],
+            "gemini": [
+                "gemini-1.5-pro",
+                "gemini-1.5-flash",
+                "gemini-1.0-pro"
+            ]
+        }
+    
+    def validate(self) -> None:
+        """Validate configuration and raise errors for missing required values."""
+        if not self.database_url:
+            raise ValueError("DATABASE_URL is required")
+        
+        # Validate AI service specific requirements
+        if self.ai_service == "openai" and not self.openai_api_key:
+            raise ValueError("OPENAI_API_KEY is required for OpenAI service")
+        elif self.ai_service == "aws" and (not self.aws_access_key_id or not self.aws_secret_access_key):
+            raise ValueError("AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required for AWS service")
+        elif self.ai_service == "watsonx" and not self.watsonx_api_key:
+            # For demo purposes, make Watsonx API key optional
+            print("Warning: WATSONX_API_KEY not provided. AI features will be limited.")
+        elif self.ai_service == "gemini" and not self.google_project_id:
+            raise ValueError("GOOGLE_PROJECT_ID is required for Gemini service")
+
+
+# Global configuration instance
+_config: Optional[Config] = None
+
+
+def get_config() -> Config:
+    """Get the global configuration instance."""
+    global _config
+    if _config is None:
+        _config = Config.from_env()
+        _config.validate()
+    return _config
+
+
+def set_config(config: Config) -> None:
+    """Set the global configuration instance (useful for testing)."""
+    global _config
+    _config = config