banko-ai-assistant 1.0.11__tar.gz → 1.0.13__tar.gz

{banko_ai_assistant-1.0.11/banko_ai_assistant.egg-info → banko_ai_assistant-1.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: banko-ai-assistant
-Version: 1.0.11
+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.13/banko_ai/__main__.py

@@ -0,0 +1,23 @@
+"""
+Main entry point for Banko AI Assistant.
+This matches the original app.py behavior.
+"""
+
+if __name__ == '__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_assistant-1.0.11 → banko_ai_assistant-1.0.13}/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_assistant-1.0.11 → banko_ai_assistant-1.0.13}/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_assistant-1.0.11 → banko_ai_assistant-1.0.13}/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_assistant-1.0.11 → banko_ai_assistant-1.0.13}/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