banko-ai-assistant 1.0.12__py3-none-any.whl → 1.0.13__py3-none-any.whl

banko_ai/__main__.py

@@ -1,10 +1,23 @@
 """
 Main entry point for Banko AI Assistant.
-
-This module allows the package to be run as a module: python -m banko_ai
+This matches the original app.py behavior.
 """
 
-from .cli import main
-
 if __name__ == '__main__':
-    main()
+    import os
+    from .web.app import create_app
+    
+    print("🏦 === Banko AI Assistant Starting === 🏦")
+    
+    # Create the Flask app
+    app = create_app()
+    
+    # Get port from environment variable or default to 5000 (matching original)
+    port = int(os.environ.get("PORT", 5000))
+    
+    print(f"🚀 Starting server on http://localhost:{port}")
+    print("🎉 Banko AI is ready to help with your finances!")
+    print("=" * 45)
+    
+    # Run the app on all interfaces, using the configured port (matching original)
+    app.run(host='0.0.0.0', port=port, debug=True)

banko_ai/ai_providers/watsonx_provider.py

@@ -76,10 +76,64 @@ class WatsonxProvider(AIProvider):
         limit: int = 10,
         threshold: float = 0.7
     ) -> List[SearchResult]:
-        """Search for expenses using vector similarity."""
-        # This method should delegate to the vector search engine
-        # For now, return empty list as the search is handled by the web app
-        return []
+        """Search for expenses using vector similarity - matches original implementation."""
+        try:
+            # Use the same simple search logic as the original watsonx.py
+            from sentence_transformers import SentenceTransformer
+            from sqlalchemy import create_engine, text
+            import json
+            
+            # Database connection (matching original)
+            DB_URI = "cockroachdb://root@localhost:26257/defaultdb?sslmode=disable"
+            engine = create_engine(DB_URI)
+            
+            # Generate embedding (matching original)
+            model = SentenceTransformer('all-MiniLM-L6-v2')
+            raw_embedding = model.encode(query)
+            search_embedding = json.dumps(raw_embedding.flatten().tolist())
+            
+            # Use exact same query as original
+            search_query = text("""
+                SELECT 
+                    description,
+                    merchant,
+                    shopping_type,
+                    expense_amount,
+                    embedding <=> :search_embedding as similarity_score
+                FROM expenses
+                ORDER BY embedding <=> :search_embedding
+                LIMIT :limit
+            """)
+            
+            with engine.connect() as conn:
+                results = conn.execute(search_query, 
+                                     {'search_embedding': search_embedding, 'limit': limit})
+                search_results = [dict(row._mapping) for row in results]
+                
+                # Convert to SearchResult objects
+                results_list = []
+                for result in search_results:
+                    results_list.append(SearchResult(
+                        expense_id="",  # Original doesn't have expense_id
+                        user_id="",     # Original doesn't have user_id
+                        description=result['description'],
+                        merchant=result['merchant'],
+                        amount=result['expense_amount'],
+                        date="",        # Original doesn't have date
+                        similarity_score=result['similarity_score'],
+                        metadata={
+                            'shopping_type': result['shopping_type'],
+                            'payment_method': 'Unknown',  # Original doesn't have this
+                            'recurring': False,
+                            'tags': []
+                        }
+                    ))
+                
+                return results_list
+                
+        except Exception as e:
+            print(f"Error in search_expenses: {e}")
+            return []
     
     def get_available_models(self) -> List[str]:
         """Get list of available Watsonx models."""
@@ -240,6 +294,143 @@ class WatsonxProvider(AIProvider):
         
         return "\n".join(recommendations) if recommendations else ""
     
+    def simple_rag_response(self, prompt: str, search_results: List[Dict[str, Any]]) -> str:
+        """
+        Simple RAG response that matches the original implementation exactly.
+        Takes a prompt and list of dictionaries (like original search results).
+        """
+        try:
+            print(f"\n🤖 SIMPLE WATSONX RAG:")
+            print(f"1. Query: '{prompt[:60]}...'")
+            
+            # Check for cached response first
+            if self.cache_manager:
+                cached_response = self.cache_manager.get_cached_response(
+                    prompt, search_results, "watsonx"
+                )
+                if cached_response:
+                    print(f"2. ✅ Response cache HIT! Returning cached response")
+                    return cached_response
+                print(f"2. ❌ Response cache MISS, generating fresh response")
+            else:
+                print(f"2. No cache manager available, generating fresh response")
+            
+            # Generate financial insights and categorization analysis (matching original)
+            insights = self._get_financial_insights_from_dicts(search_results)
+            budget_recommendations = self._generate_budget_recommendations(insights, prompt)
+            
+            # Prepare the search results context with enhanced analysis (matching original)
+            search_results_text = ""
+            if search_results:
+                search_results_text = "\n".join(
+                    f"• **{result['shopping_type']}** at {result['merchant']}: ${result['expense_amount']} - {result['description']}"
+                    for result in search_results
+                )
+                
+                # Add financial summary (matching original)
+                if insights:
+                    search_results_text += f"\n\n**📊 Financial Summary:**\n"
+                    search_results_text += f"• Total Amount: **${insights['total_amount']:.2f}**\n"
+                    search_results_text += f"• Number of Transactions: **{insights['num_transactions']}**\n"
+                    search_results_text += f"• Average Transaction: **${insights['avg_transaction']:.2f}**\n"
+                    if insights.get('top_category'):
+                        cat, amt = insights['top_category']
+                        search_results_text += f"• Top Category: **{cat}** (${amt:.2f})\n"
+            else:
+                search_results_text = "No specific expense records found for this query."
+            
+            # Create optimized prompt (matching original)
+            enhanced_prompt = f"""You are Banko, a financial assistant. Answer based on this expense data:
+
+Q: {prompt}
+
+Data:
+{search_results_text}
+
+{budget_recommendations if budget_recommendations else ''}
+
+Provide helpful insights with numbers, markdown formatting, and actionable advice."""
+            
+            # Prepare messages for chat format (matching original)
+            messages = [
+                {
+                    "role": "user",
+                    "content": enhanced_prompt
+                }
+            ]
+            
+            # Call Watsonx API (matching original implementation)
+            print(f"3. 🔄 Calling Watsonx API...")
+            response = self._call_watsonx_api(messages)
+            print(f"4. ✅ Watsonx response generated successfully")
+            
+            # Cache the response for future similar queries
+            if self.cache_manager and response:
+                # Estimate token usage (rough approximation)
+                prompt_tokens = len(enhanced_prompt.split()) * 1.3  # ~1.3 tokens per word
+                response_tokens = len(response.split()) * 1.3
+                
+                self.cache_manager.cache_response(
+                    prompt, response, search_results, "watsonx",
+                    int(prompt_tokens), int(response_tokens)
+                )
+                print(f"5. ✅ Cached response (est. {int(prompt_tokens + response_tokens)} tokens)")
+            
+            return response
+            
+        except Exception as e:
+            error_msg = f"❌ Error generating Watsonx response: {str(e)}"
+            print(error_msg)
+            
+            # Check if it's a network connectivity issue
+            if "Failed to resolve" in str(e) or "nodename nor servname provided" in str(e) or "Network connectivity issue" in str(e):
+                return f"""I apologize, but I'm experiencing network connectivity issues with IBM Watsonx AI. 
+
+**🔧 Troubleshooting suggestions:**
+- Check your internet connection
+- Try switching to AWS Bedrock by setting `AI_SERVICE=aws` in your environment
+- Verify your network allows access to `iam.cloud.ibm.com`
+
+**💡 Quick fix:** You can switch AI providers by running:
+```bash
+export AI_SERVICE=aws
+```
+
+(Network Error: {str(e)})"""
+            else:
+                return f"I apologize, but I'm experiencing technical difficulties with IBM Watsonx AI. Please try again later or consider switching to AWS Bedrock. (Error: {str(e)})"
+    
+    def _get_financial_insights_from_dicts(self, search_results: List[Dict[str, Any]]) -> dict:
+        """Generate financial insights from dictionary format (matching original)."""
+        if not search_results:
+            return {}
+        
+        total_amount = sum(float(result['expense_amount']) for result in search_results)
+        categories = {}
+        merchants = {}
+        
+        for result in search_results:
+            # Category analysis
+            category = result['shopping_type']
+            categories[category] = categories.get(category, 0) + float(result['expense_amount'])
+            
+            # Merchant analysis
+            merchant = result['merchant']
+            merchants[merchant] = merchants.get(merchant, 0) + float(result['expense_amount'])
+        
+        # Find top categories and merchants
+        top_category = max(categories.items(), key=lambda x: x[1]) if categories else None
+        top_merchant = max(merchants.items(), key=lambda x: x[1]) if merchants else None
+        
+        return {
+            'total_amount': total_amount,
+            'num_transactions': len(search_results),
+            'avg_transaction': total_amount / len(search_results) if search_results else 0,
+            'categories': categories,
+            'top_category': top_category,
+            'top_merchant': top_merchant
+        }
+
     def rag_response(
         self,
         query: str,
@@ -420,9 +611,21 @@ Provide helpful insights with numbers, markdown formatting, and actionable advic
                 print(f"2. ❌ Response cache MISS, generating fresh response")
             else:
                 print(f"2. No cache manager available, generating fresh response")
-            if not self.api_key or not self.project_id:
+            
+            # Initialize ai_response to avoid variable scope issues
+            ai_response = ""
+            
+            # FIXED: Use AI with actual search results instead of bypassing it completely
+            print(f"🔍 DEBUG: Using AI with REAL search results for query: {query}")
+            if context:
+                print(f"🔍 DEBUG: Processing {len(context)} REAL search results for AI context")
+                for i, result in enumerate(context):
+                    print(f"🔍 DEBUG: Real Result {i+1}: {result.merchant} - ${result.amount} - {result.description[:50]}...")
+            
+            # Re-enable AI generation with real search results
+            if True:  # Re-enabled AI generation with real data
                 # Return structured demo response if no API credentials
-                if not context:
+                if not self.api_key or not self.project_id:
                     ai_response = f"""## Financial Analysis for: "{query}"
 
 ### 📋 Transaction Details
@@ -438,21 +641,21 @@ I couldn't find any relevant expense records for your query. Please try:
 - Time periods (e.g., "last month", "this week")
 
 **Note**: I need API credentials to generate more detailed AI-powered insights."""
-
-                # Generate financial insights from search results
-                insights = self._get_financial_insights(context)
-                budget_recommendations = self._generate_budget_recommendations(insights, query)
-                
-                # Create table text from search results
-                table_text = ""
-                if context:
-                    table_text = "\n".join([
-                        f"• **{result.metadata.get('shopping_type', 'Unknown')}** at {result.merchant}: ${result.amount} ({result.metadata.get('payment_method', 'Unknown')}) - {result.description}"
-                        for result in context
-                    ])
-                
-                # Create context text with financial summary
-                context_text = f"""**📊 Financial Summary:**
+                else:
+                    # Generate financial insights from search results
+                    insights = self._get_financial_insights(context)
+                    budget_recommendations = self._generate_budget_recommendations(insights, query)
+                    
+                    # Create table text from search results
+                    table_text = ""
+                    if context:
+                        table_text = "\n".join([
+                            f"• **{result.metadata.get('shopping_type', 'Unknown')}** at {result.merchant}: ${result.amount} ({result.metadata.get('payment_method', 'Unknown')}) - {result.description}"
+                            for result in context
+                        ])
+                    
+                    # Create context text with financial summary
+                    context_text = f"""**📊 Financial Summary:**
 • Total Amount: ${insights.get('total_amount', 0):.2f}
 • Number of Transactions: {insights.get('num_transactions', 0)}
 • Average Transaction: ${insights.get('avg_transaction', 0):.2f}
@@ -463,6 +666,14 @@ I couldn't find any relevant expense records for your query. Please try:
 {budget_recommendations if budget_recommendations else '• Consider reviewing your spending patterns regularly' + chr(10) + '• Set up budget alerts for high-value categories'}
 
 **Note**: I can see {len(context)} relevant expense records, but I need API credentials to generate more detailed AI-powered insights."""
+                    
+                    ai_response = f"""## Financial Analysis for: "{query}"
+
+### 📋 Transaction Details
+{table_text}
+
+### 📊 Financial Summary
+{context_text}"""
             else:
                 # Make actual Watsonx API call with enhanced prompt (copied from original)
                 try:

banko_ai/config/settings.py

@@ -60,20 +60,37 @@ class Config:
     @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")
+        # Database configuration - match original app.py
+        database_url = os.getenv("DATABASE_URL", "cockroachdb://root@localhost:26257/defaultdb?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_name = os.getenv("DATABASE_NAME", "defaultdb")  # Match original
         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 configuration - match original app.py
         ai_service = os.getenv("AI_SERVICE", "watsonx").lower()
         
+        # Try to load from config.py like the original app.py does
+        try:
+            import sys
+            # Add parent directory to path to import config.py
+            parent_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+            if parent_dir not in sys.path:
+                sys.path.insert(0, parent_dir)
+            from config import WATSONX_API_KEY, WATSONX_PROJECT_ID, WATSONX_MODEL_ID
+            watsonx_api_key = WATSONX_API_KEY
+            watsonx_project_id = WATSONX_PROJECT_ID
+            watsonx_model = WATSONX_MODEL_ID
+        except ImportError:
+            # Fall back to environment variables
+            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")
+        
         return cls(
             # Database
             database_url=database_url,
@@ -92,9 +109,9 @@ class Config:
             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"),
+            watsonx_api_key=watsonx_api_key,
+            watsonx_project_id=watsonx_project_id,
+            watsonx_model=watsonx_model,
             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"),

banko_ai/utils/cache_manager.py

@@ -25,7 +25,7 @@ from sqlalchemy.dialects.postgresql import JSONB
 import os
 
 # Database configuration
-DB_URI = os.getenv('DATABASE_URL', "cockroachdb://root@localhost:26257/banko_ai?sslmode=disable")
+DB_URI = os.getenv('DATABASE_URL', "cockroachdb://root@localhost:26257/defaultdb?sslmode=disable")
 
 # Apply CockroachDB version parsing workaround
 from sqlalchemy.dialects.postgresql.base import PGDialect

banko_ai/vector_search/enrichment.py

@@ -43,7 +43,7 @@ class DataEnricher:
         **kwargs
     ) -> str:
         """
-        Enrich expense description with contextual information.
+        Create a simple description that matches the original CSV format.
         
         Args:
             description: Original expense description
@@ -55,49 +55,10 @@ class DataEnricher:
             **kwargs: Additional metadata
             
         Returns:
-            Enriched description string
+            Simple description string matching original CSV format
         """
-        # Start with the original description
-        enriched_parts = [description]
-        
-        # Add merchant name and amount prominently
-        enriched_parts.append(f"at {merchant} for ${amount:.2f}")
-        
-        # Add merchant context
-        merchant_context = self._get_merchant_context(merchant, amount)
-        if merchant_context:
-            enriched_parts.append(merchant_context)
-        
-        # Add amount context
-        amount_context = self._get_amount_context(amount)
-        if amount_context:
-            enriched_parts.append(amount_context)
-        
-        # Add category context
-        category_context = self._get_category_context(category, merchant)
-        if category_context:
-            enriched_parts.append(category_context)
-        
-        # Add payment method context
-        payment_context = self._get_payment_context(payment_method)
-        if payment_context:
-            enriched_parts.append(payment_context)
-        
-        # Add temporal context
-        temporal_context = self._get_temporal_context(date)
-        if temporal_context:
-            enriched_parts.append(temporal_context)
-        
-        # Add merchant category context
-        merchant_category = self._get_merchant_category(merchant)
-        if merchant_category:
-            enriched_parts.append(f"at {merchant_category} store")
-        
-        # Combine all parts
-        enriched_description = " ".join(enriched_parts)
-        
-        # Clean up and format
-        enriched_description = self._clean_description(enriched_description)
+        # Create the exact same format as the original CSV
+        enriched_description = f"Spent ${amount:.2f} on {category.lower()} at {merchant} using {payment_method}."
         
         return enriched_description
     
@@ -243,36 +204,15 @@ class DataEnricher:
         **kwargs
     ) -> str:
         """
-        Create a comprehensive searchable text block for embedding.
+        Create a simple searchable text that matches the original CSV format.
         
-        This creates a rich text representation that includes all relevant
-        information for vector search.
+        This creates the exact same format as the original CSV: 
+        "Spent $X.XX on [category] at [merchant] using [payment_method]."
         """
         # Extract required parameters from kwargs
-        payment_method = kwargs.get('payment_method', '')
-        date = kwargs.get('date', datetime.now())
-        
-        # Remove these from kwargs to avoid conflicts
-        filtered_kwargs = {k: v for k, v in kwargs.items() if k not in ['payment_method', 'date']}
-        
-        enriched_description = self.enrich_expense_description(
-            description, merchant, amount, category, payment_method, date, **filtered_kwargs
-        )
-        
-        # Create a comprehensive searchable text
-        searchable_parts = [
-            f"Spent ${amount:.2f} on {enriched_description}",
-            f"Merchant: {merchant}",
-            f"Category: {category}",
-            f"Amount: ${amount:.2f}"
-        ]
-        
-        # Add any additional context
-        if kwargs.get('payment_method'):
-            searchable_parts.append(f"Payment: {kwargs['payment_method']}")
+        payment_method = kwargs.get('payment_method', 'Credit Card')
         
-        if kwargs.get('tags'):
-            tags = ', '.join(kwargs['tags'])
-            searchable_parts.append(f"Tags: {tags}")
+        # Create the exact same format as the original CSV
+        searchable_text = f"Spent ${amount:.2f} on {category.lower()} at {merchant} using {payment_method}."
         
-        return " | ".join(searchable_parts)
+        return searchable_text

banko_ai/vector_search/generator.py

@@ -19,7 +19,7 @@ class EnhancedExpenseGenerator:
     
     def __init__(self, database_url: Optional[str] = None):
         """Initialize the enhanced expense generator."""
-        self.database_url = database_url or os.getenv('DATABASE_URL', "cockroachdb://root@localhost:26257/banko_ai?sslmode=disable")
+        self.database_url = database_url or os.getenv('DATABASE_URL', "cockroachdb://root@localhost:26257/defaultdb?sslmode=disable")
         self._engine = None
         self.enricher = DataEnricher()
         self._embedding_model = None
@@ -73,88 +73,77 @@ class EnhancedExpenseGenerator:
         return self._user_ids
     
     def _init_merchants_and_categories(self):
-        """Initialize merchants and categories data."""
-        # Enhanced merchant and category data
-        self._merchants = {
-            "grocery": [
-                "Whole Foods Market", "Trader Joe's", "Kroger", "Safeway", "Publix", 
-                "Walmart", "Target", "Costco", "Local Market", "Food Lion"
-            ],
-            "retail": [
-                "Amazon", "Best Buy", "Apple Store", "Home Depot", "Lowes", 
-                "Target", "Walmart", "Macy's", "Nordstrom", "TJ Maxx"
-            ],
-            "dining": [
-                "Starbucks", "McDonald's", "Chipotle", "Subway", "Pizza Hut", 
-                "Domino's", "Panera Bread", "Dunkin' Donuts", "Taco Bell", "KFC"
-            ],
-            "transportation": [
-                "Shell Gas Station", "Exxon", "Chevron", "Uber", "Lyft", 
-                "Metro", "Parking Garage", "Toll Road", "Car Wash", "Auto Repair"
-            ],
-            "healthcare": [
-                "CVS Pharmacy", "Walgreens", "Rite Aid", "Hospital", "Clinic", 
-                "Dentist", "Optometrist", "Pharmacy", "Medical Center", "Urgent Care"
-            ],
-            "entertainment": [
-                "Netflix", "Spotify", "Movie Theater", "Concert Hall", "Gaming Store", 
-                "Bookstore", "Museum", "Theme Park", "Sports Venue", "Theater"
-            ],
-            "utilities": [
-                "Electric Company", "Internet Provider", "Phone Company", "Water Company", 
-                "Gas Company", "Cable Company", "Trash Service", "Security System", "Insurance", "Bank"
-            ]
-        }
+        """Initialize merchants and categories data - matches original CSV exactly."""
+        # Use the exact merchants from the original CSV
+        self._merchants = [
+            "Starbucks", "Local Market", "McDonald's", "IKEA", "Amazon", "Whole Foods",
+            "Italian Bistro", "Uber", "Lyft", "Spotify", "Delta Airlines", "Costco",
+            "Home Depot", "Shell Gas Station", "Lowe's", "Tesla Supercharger", "Planet Fitness",
+            "Apple Store", "Walmart", "Target", "Netflix", "Best Buy", "CVS Pharmacy",
+            "Walgreens", "Rite Aid", "Chipotle", "Subway", "Pizza Hut", "Domino's",
+            "Exxon", "Chevron", "BP", "Dunkin' Donuts", "Peet's Coffee", "Ace Hardware",
+            "Movie Theater", "Concert Venue", "Gaming Store", "Electric Company",
+            "Internet Provider", "Phone Company", "Water Company"
+        ]
         
+        # Use the exact categories from the original CSV
         self._categories = {
             "Groceries": {
                 "items": ["Fresh produce", "Dairy products", "Meat and poultry", "Pantry staples", "Organic foods", "Beverages", "Snacks"],
-                "merchants": self.merchants["grocery"],
                 "amount_range": (10, 150)
             },
-            "Transportation": {
-                "items": ["Gas fill-up", "Uber ride", "Metro card reload", "Parking fee", "Car maintenance", "Toll payment", "Car wash"],
-                "merchants": self.merchants["transportation"],
-                "amount_range": (5, 100)
-            },
-            "Dining": {
-                "items": ["Coffee and pastry", "Lunch meeting", "Dinner date", "Fast food", "Food delivery", "Restaurant meal", "Catering"],
-                "merchants": self.merchants["dining"],
-                "amount_range": (8, 80)
+            "Home Improvement": {
+                "items": ["Tools", "Hardware", "Paint", "Lumber", "Electrical supplies", "Plumbing supplies", "Garden supplies"],
+                "amount_range": (20, 500)
             },
-            "Entertainment": {
-                "items": ["Movie tickets", "Streaming service", "Concert tickets", "Gaming", "Books", "Magazine subscription", "Music"],
-                "merchants": self.merchants["entertainment"],
-                "amount_range": (5, 200)
+            "Electronics": {
+                "items": ["Smartphone", "Laptop", "Tablet", "Headphones", "Camera", "Gaming console", "Smart home device"],
+                "amount_range": (50, 1000)
             },
-            "Healthcare": {
-                "items": ["Prescription medication", "Doctor visit", "Dental cleaning", "Vitamins", "Health insurance", "Medical test", "Therapy"],
-                "merchants": self.merchants["healthcare"],
-                "amount_range": (15, 500)
+            "Subscription": {
+                "items": ["Streaming service", "Software subscription", "Gym membership", "News subscription", "Cloud storage", "Music service"],
+                "amount_range": (10, 50)
             },
             "Shopping": {
-                "items": ["Clothing", "Electronics", "Home goods", "Personal care", "Gifts", "Furniture", "Appliances"],
-                "merchants": self.merchants["retail"],
-                "amount_range": (20, 1000)
+                "items": ["Clothing", "Shoes", "Accessories", "Home decor", "Books", "Toys", "Beauty products"],
+                "amount_range": (15, 200)
+            },
+            "Restaurant": {
+                "items": ["Dinner", "Lunch", "Breakfast", "Takeout", "Delivery", "Catering", "Fine dining"],
+                "amount_range": (15, 100)
+            },
+            "Transport": {
+                "items": ["Uber ride", "Lyft ride", "Taxi", "Bus fare", "Train ticket", "Flight", "Car rental"],
+                "amount_range": (5, 500)
+            },
+            "Fuel": {
+                "items": ["Gas fill-up", "Electric charging", "Diesel fuel", "Premium gas", "Regular gas"],
+                "amount_range": (20, 100)
+            },
+            "Travel": {
+                "items": ["Flight", "Hotel", "Car rental", "Travel insurance", "Airport parking", "Baggage fee"],
+                "amount_range": (100, 2000)
             },
-            "Utilities": {
-                "items": ["Electric bill", "Internet service", "Phone bill", "Water bill", "Trash service", "Cable TV", "Security system"],
-                "merchants": self.merchants["utilities"],
-                "amount_range": (30, 300)
+            "Coffee": {
+                "items": ["Coffee", "Espresso", "Latte", "Cappuccino", "Pastry", "Sandwich", "Breakfast"],
+                "amount_range": (3, 25)
             }
         }
         
-        self._payment_methods = ["Credit Card", "Debit Card", "Cash", "Mobile Payment", "Bank Transfer", "Check"]
+        # Use the exact payment methods from the original CSV
+        self._payment_methods = [
+            "Debit Card", "PayPal", "Apple Pay", "Bank Transfer", "Credit Card"
+        ]
         self._user_ids = [str(uuid.uuid4()) for _ in range(100)]  # Generate 100 user IDs
     
     def generate_expense(self, user_id: Optional[str] = None) -> Dict[str, Any]:
-        """Generate a single enriched expense record."""
+        """Generate a single enriched expense record that matches the original CSV format."""
         # Select category and get associated data
         category = random.choice(list(self.categories.keys()))
         category_data = self.categories[category]
         
-        # Select merchant from category-specific merchants
-        merchant = random.choice(category_data["merchants"])
+        # Select merchant from the full merchant list (matching original CSV)
+        merchant = random.choice(self.merchants)
         
         # Generate amount within category range
         amount = round(random.uniform(*category_data["amount_range"]), 2)
@@ -171,29 +160,14 @@ class EnhancedExpenseGenerator:
         
         # Generate additional metadata
         payment_method = random.choice(self.payment_methods)
-        recurring = random.choice([True, False]) if category in ["Utilities", "Entertainment"] else False
+        recurring = random.choice([True, False]) if category in ["Subscription", "Coffee"] else False
         tags = [category.lower(), merchant.lower().replace(" ", "_")]
         
-        # Enrich the description
-        enriched_description = self.enricher.enrich_expense_description(
-            description=basic_description,
-            merchant=merchant,
-            amount=amount,
-            category=category,
-            payment_method=payment_method,
-            date=expense_date,
-            tags=tags
-        )
+        # Create the exact same description format as the original CSV
+        enriched_description = f"Spent ${amount:.2f} on {category.lower()} at {merchant} using {payment_method}."
         
-        # Create searchable text for embedding
-        searchable_text = self.enricher.create_searchable_text(
-            description=basic_description,
-            merchant=merchant,
-            amount=amount,
-            category=category,
-            payment_method=payment_method,
-            tags=tags
-        )
+        # Create searchable text for embedding (same as description for simplicity)
+        searchable_text = enriched_description
         
         # Generate embedding
         embedding = self.embedding_model.encode([searchable_text])[0].tolist()

banko_ai/vector_search/search.py

@@ -19,7 +19,7 @@ class VectorSearchEngine:
     
     def __init__(self, database_url: Optional[str] = None, cache_manager=None):
         """Initialize the vector search engine."""
-        self.database_url = database_url or os.getenv('DATABASE_URL', "cockroachdb://root@localhost:26257/banko_ai?sslmode=disable")
+        self.database_url = database_url or os.getenv('DATABASE_URL', "cockroachdb://root@localhost:26257/defaultdb?sslmode=disable")
         self.cache_manager = cache_manager
         
         # Apply version parsing workaround for CockroachDB
@@ -46,6 +46,48 @@ class VectorSearchEngine:
         )
         self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
     
+    def simple_search_expenses(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Simple search function that matches the original implementation exactly.
+        Returns list of dictionaries like the original search_expenses function.
+        """
+        try:
+            print(f"\n🔍 SIMPLE VECTOR SEARCH:")
+            print(f"1. Query: '{query}' | Limit: {limit}")
+            
+            # Generate embedding
+            raw_embedding = self.embedding_model.encode(query)
+            print(f"2. Generated embedding with {len(raw_embedding)} dimensions")
+            
+            # Convert to PostgreSQL vector format (matching original implementation)
+            import json
+            search_embedding = json.dumps(raw_embedding.flatten().tolist())
+            
+            # Use the exact same query as the original implementation
+            search_query = text("""
+                SELECT 
+                    description,
+                    merchant,
+                    shopping_type,
+                    expense_amount,
+                    embedding <=> :search_embedding as similarity_score
+                FROM expenses
+                ORDER BY embedding <=> :search_embedding
+                LIMIT :limit
+            """)
+            
+            with self.engine.connect() as conn:
+                results = conn.execute(search_query, 
+                                     {'search_embedding': search_embedding, 'limit': limit})
+                search_results = [dict(row._mapping) for row in results]
+                print(f"3. Database query returned {len(search_results)} expense records")
+                
+                return search_results
+                
+        except Exception as e:
+            print(f"❌ Error executing simple expense search query: {e}")
+            return []
+    
     def search_expenses(
         self, 
         query: str, 

banko_ai/web/app.py

@@ -28,6 +28,109 @@ from ..utils.cache_manager import BankoCacheManager
 from .auth import UserManager
 
 
+def check_database_connection(database_url: str):
+    """
+    Check if the database is accessible and has the required table.
+    Matches the original app.py implementation.
+    
+    Returns:
+        tuple: (success: bool, message: str, table_exists: bool, record_count: int)
+    """
+    try:
+        engine = create_engine(database_url)
+        
+        with engine.connect() as conn:
+            # Test basic connection
+            result = conn.execute(text('SELECT version()'))
+            version = result.fetchone()[0]
+            
+            # Check if expenses table exists
+            result = conn.execute(text("""
+                SELECT table_name 
+                FROM information_schema.tables 
+                WHERE table_schema = 'public' AND table_name = 'expenses'
+            """))
+            table_exists = result.fetchone() is not None
+            
+            record_count = 0
+            if table_exists:
+                result = conn.execute(text('SELECT COUNT(*) FROM expenses'))
+                record_count = result.fetchone()[0]
+            
+            return True, f"Connected to {version.split()[1]}", table_exists, record_count
+            
+    except Exception as e:
+        return False, f"Database connection failed: {str(e)}", False, 0
+
+
+def auto_setup_data_if_needed(database_url: str):
+    """
+    Automatically set up data if the database is empty or has very few records.
+    This integrates seamlessly into the app startup - matches original app.py.
+    """
+    try:
+        db_connected, db_message, table_exists, record_count = check_database_connection(database_url)
+        
+        if not db_connected:
+            print(f"❌ Database connection failed: {db_message}")
+            return False
+            
+        # Create table if it doesn't exist
+        if not table_exists:
+            print("🔧 Creating expenses table...")
+            try:
+                import subprocess
+                import sys
+                import os
+                # Get the project root directory
+                project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+                create_table_script = os.path.join(project_root, 'vector_search', 'create_table.py')
+                
+                if os.path.exists(create_table_script):
+                    result = subprocess.run([sys.executable, create_table_script], 
+                                          capture_output=True, text=True, cwd=project_root)
+                    if result.returncode == 0:
+                        print("✅ Expenses table created successfully")
+                        # Re-check the database status
+                        db_connected, db_message, table_exists, record_count = check_database_connection(database_url)
+                    else:
+                        print(f"❌ Failed to create table: {result.stderr}")
+                        return False
+                else:
+                    print(f"❌ Table creation script not found: {create_table_script}")
+                    return False
+            except Exception as e:
+                print(f"❌ Table creation error: {e}")
+                return False
+            
+        # If we have very few records, offer to generate more
+        if record_count < 100:
+            print(f"🔍 Found {record_count} expense records")
+            print("🎯 Generating sample data for better demo experience...")
+            
+            try:
+                # Use the unified data generator
+                from ..vector_search.generator import EnhancedExpenseGenerator
+                
+                generator = EnhancedExpenseGenerator(database_url)
+                
+                # Generate a reasonable amount for demos (5K records)
+                generator.generate_and_save(5000, user_id=None, clear_existing=False)
+                
+                print("✅ Generated 5,000 realistic expense records")
+                return True
+                
+            except Exception as e:
+                print(f"⚠️  Data generation failed: {e}")
+                return False
+        
+        return True
+        
+    except Exception as e:
+        print(f"⚠️  Auto-setup error: {e}")
+        return False
+
+
 def create_app() -> Flask:
     """Create and configure the Flask application."""
     # Get the directory containing this file
@@ -74,6 +177,10 @@ def create_app() -> Flask:
         print(f"Warning: Could not initialize AI provider: {e}")
         ai_provider = None
     
+    # Auto-setup data if needed (matching original app.py)
+    print("🔍 Checking database setup...")
+    auto_setup_data_if_needed(config.database_url)
+    
     @app.route('/')
     def index():
         """Main application page."""
@@ -111,35 +218,17 @@ def create_app() -> Flask:
             query = data.get('query', '')
             limit = data.get('limit', 10)
             threshold = data.get('threshold', 0.7)
-            current_user = user_manager.get_current_user()
-            user_id = current_user['id'] if current_user else None
-            
-            print(f"🔍 API Search Debug: query='{query}', limit={limit}, threshold={threshold}, user_id={user_id}")
-            
-            # If no user is logged in, search all expenses (no user filtering)
-            # This ensures we get results from the database
-            if user_id is None:
-                results = search_engine.search_expenses(
-                    query=query,
-                    user_id=None,
-                    limit=limit,
-                    threshold=threshold
-                )
-            else:
-                results = search_engine.search_expenses(
-                    query=query,
-                    user_id=user_id,
-                    limit=limit,
-                    threshold=threshold
-                )
-            
-            print(f"🔍 API Search Debug: search_engine returned {len(results) if results else 0} results")
+            # Use original simple logic - no user filtering
+            results = search_engine.search_expenses(
+                query=query,
+                user_id=None,  # No user filtering like original
+                limit=limit,
+                threshold=threshold
+            )
             
             # Convert to serializable format
             search_results = []
-            print(f"🔍 API Search Debug: Processing {len(results) if results else 0} results")
-            for i, result in enumerate(results):
-                print(f"🔍 API Search Debug: Processing result {i+1}: {result.description[:50]}... (score: {result.similarity_score})")
+            for result in results:
                 search_results.append({
                     'expense_id': result.expense_id,
                     'user_id': result.user_id,
@@ -151,13 +240,11 @@ def create_app() -> Flask:
                     'metadata': result.metadata
                 })
             
-            print(f"🔍 API Search Debug: Final search_results has {len(search_results)} items")
-            
             return jsonify({
                 'success': True,
                 'results': search_results,
                 'query': query,
-                'user_id': user_id
+                'user_id': None
             })
             
         except Exception as e:
@@ -179,30 +266,19 @@ def create_app() -> Flask:
             data = request.get_json()
             query = data.get('query', '')
             language = data.get('language', 'en')
-            user_id = user_manager.get_current_user()['id'] if user_manager.is_logged_in() else None
+            # Use original simple logic - no user filtering
+            search_results = search_engine.search_expenses(
+                query=query,
+                user_id=None,  # No user filtering like original
+                limit=5,
+                threshold=0.7
+            )
             
-            # If no user is logged in, search all expenses (no user filtering)
-            # This ensures we get results from the database
-            if user_id is None:
-                search_results = search_engine.search_expenses(
-                    query=query,
-                    user_id=None,
-                    limit=5,
-                    threshold=0.7
-                )
-            else:
-                search_results = search_engine.search_expenses(
-                    query=query,
-                    user_id=user_id,
-                    limit=5,
-                    threshold=0.7
-                )
-            
-            # Generate RAG response
+            # Generate RAG response - use original simple logic
             rag_response = ai_provider.generate_rag_response(
                 query=query,
                 context=search_results,
-                user_id=user_id,
+                user_id=None,  # No user filtering like original
                 language=language
             )
             
@@ -396,16 +472,15 @@ def create_app() -> Flask:
 
     @app.route('/banko', methods=['GET', 'POST'])
     def chat():
-        """Main chat interface."""
+        """Main chat interface - using original simple logic."""
         if 'chat' not in session:
             session['chat'] = []
         
         # Get AI provider info for display
-        provider_info = ai_provider.get_provider_info() if ai_provider else {'name': 'Unknown', 'current_model': 'Unknown'}
         ai_provider_display = {
-            'name': provider_info['name'],
-            'current_service': config.ai_service.upper(),
-            'icon': '🧠' if config.ai_service.lower() == 'watsonx' else '☁️'
+            'name': 'IBM Watsonx',
+            'current_service': 'WATSONX',
+            'icon': '🧠'
         }
         
         if request.method == 'POST':
@@ -434,42 +509,52 @@ def create_app() -> Flask:
                 target_language = language_map.get(response_language, 'English')
                 
                 try:
-                    # Search for relevant expenses using the configured AI service
-                    current_user = user_manager.get_current_user()
-                    user_id = current_user['id'] if current_user else None
-                    
-                    # If no user is logged in, search all expenses (no user filtering)
-                    # This ensures we get results from the database
-                    if user_id is None:
-                        result = search_engine.search_expenses(
-                            query=prompt,
-                            user_id=None,
-                            limit=10,
-                            threshold=0.7
-                        )
+                    # Use simple search that matches original implementation
+                    if hasattr(ai_provider, 'search_expenses'):
+                        # Use the simple search method that returns dictionaries like original
+                        search_results = ai_provider.search_expenses(prompt, limit=10)
                     else:
-                        result = search_engine.search_expenses(
-                            query=prompt,
-                            user_id=user_id,
-                            limit=10,
-                            threshold=0.7
-                        )
-                    print(f"Using {provider_info['name']} for response generation in {target_language}")
+                        # Fallback to search engine simple method
+                        search_results = search_engine.simple_search_expenses(prompt, limit=10)
+                    
+                    print(f"Using watsonx for response generation in {target_language}")
                     
-                    # Generate RAG response with language preference
+                    # Convert SearchResult objects to dictionaries if needed
+                    if search_results and hasattr(search_results[0], 'description'):
+                        # Convert SearchResult objects to dict format
+                        search_results_dict = []
+                        for result in search_results:
+                            search_results_dict.append({
+                                'description': result.description,
+                                'merchant': result.merchant,
+                                'shopping_type': result.metadata.get('shopping_type', 'Unknown'),
+                                'expense_amount': result.amount,
+                                'similarity_score': result.similarity_score
+                            })
+                        search_results = search_results_dict
+                    
+                    # Generate RAG response with language preference - use original simple approach
                     if target_language != 'English':
                         enhanced_prompt = f"{user_message}\n\nPlease respond in {target_language}."
-                        rag_response = ai_provider.generate_rag_response(enhanced_prompt, result, user_id, response_language)
+                        if hasattr(ai_provider, 'simple_rag_response'):
+                            rag_response_text = ai_provider.simple_rag_response(enhanced_prompt, search_results)
+                        else:
+                            rag_response = ai_provider.generate_rag_response(enhanced_prompt, search_results, None, response_language)
+                            rag_response_text = rag_response.response if hasattr(rag_response, 'response') else str(rag_response)
                     else:
-                        rag_response = ai_provider.generate_rag_response(user_message, result, user_id, response_language)
-                        
-                    print(f"Response from {provider_info['name']}: {rag_response.response}")
+                        if hasattr(ai_provider, 'simple_rag_response'):
+                            rag_response_text = ai_provider.simple_rag_response(user_message, search_results)
+                        else:
+                            rag_response = ai_provider.generate_rag_response(user_message, search_results, None, response_language)
+                            rag_response_text = rag_response.response if hasattr(rag_response, 'response') else str(rag_response)
+                    
+                    print(f"Response from watsonx: {rag_response_text}")
                     
-                    session['chat'].append({'text': rag_response.response, 'class': 'Assistant'})
+                    session['chat'].append({'text': rag_response_text, 'class': 'Assistant'})
                     
                 except Exception as e:
-                    error_message = f"Sorry, I'm experiencing technical difficulties with {provider_info['name']}. Please try again later."
-                    print(f"Error with {provider_info['name']}: {str(e)}")
+                    error_message = f"Sorry, I'm experiencing technical difficulties. Error: {str(e)}"
+                    print(f"Error with watsonx: {str(e)}")
                     session['chat'].append({'text': error_message, 'class': 'Assistant'})
                     
         return render_template('index.html', 

{banko_ai_assistant-1.0.12.dist-info → banko_ai_assistant-1.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: banko-ai-assistant
-Version: 1.0.12
+Version: 1.0.13
 Summary: AI-powered expense analysis and RAG system with CockroachDB vector search and multi-provider AI support
 Author-email: Virag Tripathi <virag.tripathi@gmail.com>
 License-Expression: MIT

{banko_ai_assistant-1.0.12.dist-info → banko_ai_assistant-1.0.13.dist-info}/RECORD

@@ -1,5 +1,5 @@
 banko_ai/__init__.py,sha256=G1InyKemqQxP9xx6yGZgolBmrmOLSpBXqGYY8LaFOeo,568
-banko_ai/__main__.py,sha256=vySUZt0uAzogVu6yURIlLJ1Ig5bdxT_55oiiaiZKqA8,185
+banko_ai/__main__.py,sha256=U-KkrXtL8JNIyV25PE5v_eYhlhjR7jd6kG-txfYfs0M,709
 banko_ai/cli.py,sha256=SsCsikOykmTM_uId-n0ivilKXu1hKch17XXwhMHfFnU,13760
 banko_ai/ai_providers/__init__.py,sha256=JdBgw5Mji2pe9nU-aiRYUmJuZk0q8KbcMtbpMJC5Dq8,483
 banko_ai/ai_providers/aws_provider.py,sha256=-tR-8tlEeSL-Fspx05tTMFguvQylkW_pz0PI2XJEByM,13074
@@ -7,9 +7,9 @@ banko_ai/ai_providers/base.py,sha256=zbuAgkHIfJ0YkG83LXzieJuvXBcB2-nx7NhbL-I4Pf0
 banko_ai/ai_providers/factory.py,sha256=Bqq9HcbyTfPvaOTxsHSM9eSvkB71cJoq21cMmXo4LLc,2885
 banko_ai/ai_providers/gemini_provider.py,sha256=KqzHLLl7EYnai9-zFenRmktVk0zOA8AtsYScQZIcdLU,13044
 banko_ai/ai_providers/openai_provider.py,sha256=Myu2And6kTD2EgIVcWHGak5fDIq0pu1HQzf-jj72y3k,11657
-banko_ai/ai_providers/watsonx_provider.py,sha256=4rLg4GmEpM7w4bCaJWnAOIprx7olHtg2zZ3o9RDkxzM,29422
+banko_ai/ai_providers/watsonx_provider.py,sha256=Jl33LKApIED4nl2EmhpSp3x7aFYe4d2QSqq5udtGlZg,39258
 banko_ai/config/__init__.py,sha256=YObKfKjjW89kSfARiTzXnGuSPz1C92aSMKgmO3BtQb8,133
-banko_ai/config/settings.py,sha256=_9LoMVLNx_BoHK1tFU0tFNBpco1VGOYjTChghdzNQ9Y,8437
+banko_ai/config/settings.py,sha256=6M8YoaxzyCULn6BOot4hahtDkgjsgyLmMd8BxDKVt4k,9317
 banko_ai/static/Anallytics.png,sha256=fWLddd5hlB4YEUYSIzOFVNnTny6D8VExQeVn31mywTc,80242
 banko_ai/static/Graph.png,sha256=eOPCPBUAs6KGeIWbDk9aDt_pJYRxBCzm4dkYQ7xdj4g,58591
 banko_ai/static/Graph2.png,sha256=nVj9Qdu5hvBI3AoWAMnL7WJb-T22aaBX3ATVsDXTM2I,32462
@@ -146,19 +146,19 @@ banko_ai/templates/dashboard.html,sha256=-HIQ3sU86hqVn1jGeHV8_w2HlnPZ4uS2cD-BNGU
 banko_ai/templates/index.html,sha256=SkDXWH_ttH2T_a_46_OETgy1Q3zDfvot9eEKGB0S1x0,66973
 banko_ai/templates/login.html,sha256=YPMtJcvCzFlknwmUrG7VskeM691J4msAjZw-t4CcPn4,2063
 banko_ai/utils/__init__.py,sha256=0n1JYzZUWwgwOzV82I6OnmfUV_TOnal1V0DoEb0E2Cs,225
-banko_ai/utils/cache_manager.py,sha256=EK_hRNKjMbrzlHGP3M1fO_71H0NdAobY_S9dzE4_-xI,22384
+banko_ai/utils/cache_manager.py,sha256=fFnHk6dGui3T1KrSNKTYKdonCD7Fc8VvhDBhqmL-syc,22385
 banko_ai/utils/database.py,sha256=sJYAFTApkWReEJuMbbBDiz7XfgiiEd6lPSSyF6BQDpk,7754
 banko_ai/utils/migration.py,sha256=j1lYUVZyYMcMvxZUOFymoK19QTPqkDZFXD-iysVCnQo,4764
 banko_ai/vector_search/__init__.py,sha256=vYksnkUU4FA8XBNzYZIH4FoGjXCx9oIbrDeapSzrNuE,621
-banko_ai/vector_search/enrichment.py,sha256=sRnFLNG9WGfq8j44T7krxHI-Lc2RSH68mt0IT0GTHBA,10203
-banko_ai/vector_search/generator.py,sha256=BAs26Uwt-8VP9xPsTdooxznLnr674uX_jr41_oKZKL8,16912
-banko_ai/vector_search/search.py,sha256=k3wo3zFJH9o-kBc-vAS-bdmM3LGX2vIk3u4cRA5QPXo,16915
+banko_ai/vector_search/enrichment.py,sha256=tgAImLehkp2kL46vI5GEHsE8B5E4gT3PweXZLqqKei4,8097
+banko_ai/vector_search/generator.py,sha256=KAXp8wr7xXI9hzYRslyMhYaFHbticbWpT-a2RmJgmy4,16087
+banko_ai/vector_search/search.py,sha256=I-DgxTqib_VbRKX0Ttk9QmzGcAW2hLYm0_Y9HXSaibQ,18763
 banko_ai/web/__init__.py,sha256=hjWVVxYpIZhOAN1qBf4xTd36a5AUHM03Q8BF8pykhJQ,363
-banko_ai/web/app.py,sha256=hNRtCfmLf8UdjFgp96lKASSGJ_fosleBMIAmAJ9LZUQ,28288
+banko_ai/web/app.py,sha256=Qdd9gIccFJ5NeEYFiwKS3evFNbba6t5LNs733isloWE,32127
 banko_ai/web/auth.py,sha256=js6qIixSFHyLbETDm8GNLCPrDkCDcaQZPFOrqtZP1uw,2125
-banko_ai_assistant-1.0.12.dist-info/licenses/LICENSE,sha256=skG0LkywIClj8fgSIXiG6o9vUDJ678BKBObIyJ19OMw,1075
-banko_ai_assistant-1.0.12.dist-info/METADATA,sha256=Ml4D_9W8csDLr_vs5y6KTZmwIfud9RgwKerJj2YOcqM,13244
-banko_ai_assistant-1.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-banko_ai_assistant-1.0.12.dist-info/entry_points.txt,sha256=IxPjBjMvbpCp-ikCA43bOSbYboTGPX4HYcZlvu2_vcA,47
-banko_ai_assistant-1.0.12.dist-info/top_level.txt,sha256=xNMa9Z67UssefOQ2ubFObtqUYIfYmCIclfz0xdo5OPE,9
-banko_ai_assistant-1.0.12.dist-info/RECORD,,
+banko_ai_assistant-1.0.13.dist-info/licenses/LICENSE,sha256=skG0LkywIClj8fgSIXiG6o9vUDJ678BKBObIyJ19OMw,1075
+banko_ai_assistant-1.0.13.dist-info/METADATA,sha256=HBUsepFohIoHmecHe7hQAXgbE5La1FTvti2c3Jkn0S0,13244
+banko_ai_assistant-1.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+banko_ai_assistant-1.0.13.dist-info/entry_points.txt,sha256=IxPjBjMvbpCp-ikCA43bOSbYboTGPX4HYcZlvu2_vcA,47
+banko_ai_assistant-1.0.13.dist-info/top_level.txt,sha256=xNMa9Z67UssefOQ2ubFObtqUYIfYmCIclfz0xdo5OPE,9
+banko_ai_assistant-1.0.13.dist-info/RECORD,,