memory_agent.py

"""
Memory-enhanced AI Agent for Chrome Extension Idea Generation
Combines OpenAI with vector memory for improved ideation
"""

import os
import json
import time
from typing import List, Dict, Any, Optional, Union
from datetime import datetime

import openai
from dotenv import load_dotenv

# Import the vector memory system
from vector_memory import get_vector_memory

# Load environment variables
load_dotenv()

class MemoryEnhancedAgent:
    """
    AI Agent with memory capabilities for Chrome extension idea generation
    Leverages OpenAI and vector memory for improved ideation
    """
    
    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the memory-enhanced agent
        
        Args:
            api_key: OpenAI API key (default: use environment variable)
        """
        # Use environment variable if API key not provided
        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
        
        # Set up OpenAI client
        self.client = openai.OpenAI(api_key=self.api_key)
        
        # Get vector memory singleton
        self.memory = get_vector_memory()
        
        # Track whether memory is available
        self.has_memory = self.memory.is_available
    
    def generate_ideas(self, 
                      extension_data: str, 
                      word_bank: Optional[List[str]] = None,
                      count: int = 3,
                      use_memory: bool = True) -> List[Dict[str, Any]]:
        """
        Generate Chrome extension ideas with memory enhancement
        
        Args:
            extension_data: Scraped extension data or requirements
            word_bank: Optional list of niche keywords to focus on
            count: Number of ideas to generate
            use_memory: Whether to use vector memory for enhancement
            
        Returns:
            List of idea dictionaries
        """
        # Create a prompt with memory context if available and requested
        memory_context = ""
        if use_memory and self.has_memory:
            # Generate a query from the inputs
            query = f"Chrome extensions for {' '.join(word_bank[:3] if word_bank else [])}"
            
            # Get context from memory
            memory_context = self.memory.get_context_for_prompt(query)
        
        # Create the prompt
        prompt = self._create_prompt(extension_data, word_bank, memory_context)
        
        try:
            # Call OpenAI to generate ideas
            response = self.client.chat.completions.create(
                model="gpt-4o",  # the newest OpenAI model is "gpt-4o" which was released May 13, 2024. do not change this unless explicitly requested by the user
                messages=[
                    {"role": "system", "content": "You are an expert in Chrome extension development and market research."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.8,
                max_tokens=2000,
                response_format={"type": "json_object"}
            )
            
            # Parse the response
            result = json.loads(response.choices[0].message.content)
            ideas = result.get("ideas", [])
            
            # Store ideas in memory if available
            if self.has_memory and ideas:
                # Add source information
                for idea in ideas:
                    idea["source"] = "AI Generator"
                    idea["createdAt"] = datetime.now().isoformat()
                
                # Store in vector memory
                self.memory.store_multiple_ideas(ideas)
            
            return ideas
        except Exception as e:
            print(f"Error generating ideas with memory agent: {str(e)}")
            return []
    
    def _create_prompt(self, 
                      extension_data: str, 
                      word_bank: Optional[List[str]] = None,
                      memory_context: str = "") -> str:
        """
        Create a prompt for the AI based on data, word bank, and memory context
        
        Args:
            extension_data: Scraped extension data
            word_bank: Optional list of keywords
            memory_context: Context from vector memory
            
        Returns:
            Formatted prompt string
        """
        prompt = "Generate innovative Chrome extension ideas based on the following information:\n\n"
        
        # Add memory context if available
        if memory_context:
            prompt += "MEMORY CONTEXT:\n" + memory_context + "\n\n"
        
        # Add extension data if available
        if extension_data:
            prompt += "EXTENSION DATA:\n" + extension_data + "\n\n"
        
        # Add word bank if available
        if word_bank and len(word_bank) > 0:
            prompt += "NICHE KEYWORDS:\n" + ", ".join(word_bank) + "\n\n"
        
        # Add specific instructions for output format
        prompt += """
For each idea, please provide:
1. Name - The extension name
2. Problem - The user pain point it solves
3. Description - Brief explanation of what it does
4. Features - List of key features (at least 3)
5. Keywords - List of related keywords for SEO
6. SuggestedAudience - Who would use this extension
7. Competition - Level of competition (High, Medium, Low)
8. OriginalityScore - A score from 1-10 rating how innovative this idea is
9. Monetization - Ideas for monetization strategies
10. WhyNow - Why this extension is timely and needed now

If you're generating multiple ideas, make at least one a hybrid concept that combines two seemingly unrelated niches in a novel way.

Respond with a JSON object in this format:
{
  "ideas": [
    {
      "name": "Extension Name",
      "problem": "Problem statement",
      "description": "Description",
      "features": ["Feature 1", "Feature 2", "Feature 3"],
      "keywords": ["keyword1", "keyword2", "keyword3"],
      "suggestedAudience": ["Audience 1", "Audience 2"],
      "competition": "Low/Medium/High",
      "originalityScore": 8,
      "monetization": ["Strategy 1", "Strategy 2"],
      "whyNow": "Reason why it's relevant now",
      "isHybrid": false
    }
  ]
}
"""
        return prompt
    
    def analyze_extension_idea(self, idea: Dict[str, Any]) -> Dict[str, Any]:
        """
        Enhance and analyze an extension idea with insights from memory
        
        Args:
            idea: The extension idea to analyze
            
        Returns:
            Enhanced idea with additional insights
        """
        if not self.has_memory:
            # Without memory, just return the original idea
            return idea
        
        try:
            # Generate a query from the idea
            query = f"{idea.get('name', '')} {idea.get('problem', '')}"
            
            # Get memory context for similar ideas
            memory_context = self.memory.get_context_for_prompt(query)
            
            # Create a prompt for analysis
            prompt = f"""
Analyze this Chrome extension idea and provide deeper insights based on similar ideas:

EXTENSION IDEA:
Name: {idea.get('name', 'Untitled')}
Problem: {idea.get('problem', 'N/A')}
Description: {idea.get('description', 'N/A')}
Features: {', '.join(idea.get('features', []))}
Keywords: {', '.join(idea.get('keywords', []))}
Target Audience: {', '.join(idea.get('suggestedAudience', []))}

MEMORY CONTEXT:
{memory_context}

Please provide:
1. Enhanced features with more detail
2. Potential challenges and how to overcome them
3. Differentiation strategy from existing solutions
4. Growth strategy recommendations
5. Refined target audience segments
6. Development complexity estimate (Low, Medium, High)

Respond in JSON format.
"""
            
            # Call OpenAI for analysis
            response = self.client.chat.completions.create(
                model="gpt-4o",  # the newest OpenAI model is "gpt-4o" which was released May 13, 2024. do not change this unless explicitly requested by the user
                messages=[
                    {"role": "system", "content": "You are an expert in Chrome extension development and market research."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.7,
                max_tokens=1500,
                response_format={"type": "json_object"}
            )
            
            # Parse the response
            result = json.loads(response.choices[0].message.content)
            
            # Add analysis to idea
            enhanced_idea = idea.copy()
            
            # Add enhanced insights
            if 'enhancedFeatures' in result:
                enhanced_idea['enhancedFeatures'] = result['enhancedFeatures']
            
            if 'challenges' in result:
                enhanced_idea['challenges'] = result['challenges']
            
            if 'differentiationStrategy' in result:
                enhanced_idea['differentiationStrategy'] = result['differentiationStrategy']
            
            if 'growthStrategy' in result:
                enhanced_idea['growthStrategy'] = result['growthStrategy']
            
            if 'refinedAudience' in result:
                enhanced_idea['refinedAudience'] = result['refinedAudience']
            
            if 'developmentComplexity' in result:
                enhanced_idea['developmentComplexity'] = result['developmentComplexity']
            
            # Update memory with insights
            insight_text = json.dumps(result, indent=2)
            if 'id' in enhanced_idea and enhanced_idea['id']:
                self.memory.add_insight(enhanced_idea['id'], insight_text)
            
            return enhanced_idea
        except Exception as e:
            print(f"Error analyzing idea with memory agent: {str(e)}")
            return idea


def run(extension_data: str, word_bank: Optional[List[str]] = None) -> List[Dict[str, str]]:
    """
    Run the memory-enhanced agent to generate Chrome extension ideas
    
    Args:
        extension_data: Scraped extension data or requirements
        word_bank: Optional list of niche keywords to focus on
        
    Returns:
        List of generated ideas
    """
    agent = MemoryEnhancedAgent()
    return agent.generate_ideas(extension_data, word_bank)