Create app.py

app.py

@@ -0,0 +1,422 @@
+import gradio as gr
+import json
+import re
+from openai import OpenAI
+from typing import List, Dict, Tuple, Optional
+import time
+import random
+
+class MemoryPalaceBuilder:
+    def __init__(self):
+        self.client = None
+        self.current_palace = None
+        self.learning_sessions = []
+        
+    def set_api_key(self, api_key: str) -> str:
+        """Initialize OpenAI client with OpenRouter API key"""
+        try:
+            self.client = OpenAI(
+                base_url="https://openrouter.ai/api/v1",
+                api_key=api_key,
+            )
+            # Test the connection with a simple request
+            test_response = self.client.chat.completions.create(
+                model="deepseek/deepseek-r1-0528-qwen3-8b:free",
+                messages=[{"role": "user", "content": "Hello, respond with 'API connection successful'"}],
+                max_tokens=50
+            )
+            return "✅ API Key validated successfully!"
+        except Exception as e:
+            return f"❌ API Key validation failed: {str(e)}"
+    
+    def analyze_space(self, space_description: str, space_type: str) -> str:
+        """Analyze the user's space and create a spatial map"""
+        if not self.client:
+            return "Please set your OpenRouter API key first."
+        
+        prompt = f"""
+        Analyze this {space_type} space and create a detailed spatial map for a memory palace:
+        
+        Space Description: {space_description}
+        
+        Please provide a structured analysis with:
+        1. Key locations/rooms/areas identified
+        2. Natural pathways and flow between areas
+        3. Distinctive features that can serve as memory anchors
+        4. Sensory elements (lighting, textures, sounds, smells)
+        5. Emotional associations or significance of different areas
+        
+        Format your response as a clear, organized spatial map that can be used for memory techniques.
+        """
+        
+        try:
+            response = self.client.chat.completions.create(
+                model="deepseek/deepseek-r1-0528-qwen3-8b:free",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=1000
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Error analyzing space: {str(e)}"
+    
+    def create_memory_palace(self, space_analysis: str, learning_content: str, content_type: str, difficulty: str) -> str:
+        """Create a memory palace mapping content to space"""
+        if not self.client:
+            return "Please set your OpenRouter API key first."
+        
+        prompt = f"""
+        Create an intelligent memory palace using advanced spatial reasoning:
+        
+        SPACE ANALYSIS:
+        {space_analysis}
+        
+        CONTENT TO MEMORIZE:
+        Type: {content_type}
+        Difficulty: {difficulty}
+        Content: {learning_content}
+        
+        Use chain-of-thought reasoning to:
+        1. Break down the content into logical chunks
+        2. Map each chunk to specific locations in the space
+        3. Create vivid, multi-sensory associations
+        4. Design a logical pathway that connects all information
+        5. Include memory triggers and retrieval cues
+        6. Add narrative elements to make it memorable
+        
+        Provide:
+        - Step-by-step journey through the memory palace
+        - Specific visualizations for each location
+        - Memory techniques and mnemonics
+        - Practice suggestions
+        
+        Make it engaging, creative, and scientifically sound for memory retention.
+        """
+        
+        try:
+            response = self.client.chat.completions.create(
+                model="deepseek/deepseek-r1-0528-qwen3-8b:free",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=1500
+            )
+            
+            palace_content = response.choices[0].message.content
+            self.current_palace = {
+                'space_analysis': space_analysis,
+                'content': learning_content,
+                'content_type': content_type,
+                'difficulty': difficulty,
+                'palace_design': palace_content,
+                'created_at': time.strftime("%Y-%m-%d %H:%M:%S")
+            }
+            return palace_content
+        except Exception as e:
+            return f"Error creating memory palace: {str(e)}"
+    
+    def generate_quiz(self, quiz_type: str) -> Tuple[str, str]:
+        """Generate quiz questions based on the current memory palace"""
+        if not self.client or not self.current_palace:
+            return "Please create a memory palace first.", ""
+        
+        prompt = f"""
+        Based on this memory palace, create a {quiz_type} quiz:
+        
+        MEMORY PALACE:
+        {self.current_palace['palace_design']}
+        
+        ORIGINAL CONTENT:
+        {self.current_palace['content']}
+        
+        Create 5 questions that test:
+        - Recall of specific information
+        - Understanding of spatial relationships
+        - Application of learned concepts
+        - Memory pathway navigation
+        
+        Format as clear questions with multiple choice or fill-in-the-blank.
+        Provide the answer key separately.
+        """
+        
+        try:
+            response = self.client.chat.completions.create(
+                model="deepseek/deepseek-r1-0528-qwen3-8b:free",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=800
+            )
+            
+            quiz_content = response.choices[0].message.content
+            
+            # Try to separate questions and answers
+            if "ANSWER KEY" in quiz_content or "ANSWERS" in quiz_content:
+                parts = re.split(r"ANSWER[S]?\s*KEY|ANSWERS", quiz_content, flags=re.IGNORECASE)
+                questions = parts[0].strip()
+                answers = parts[1].strip() if len(parts) > 1 else "Answers included in response above."
+            else:
+                questions = quiz_content
+                answers = "Answers are integrated with questions above."
+            
+            return questions, answers
+        except Exception as e:
+            return f"Error generating quiz: {str(e)}", ""
+    
+    def get_study_tips(self) -> str:
+        """Get personalized study tips and techniques"""
+        if not self.client or not self.current_palace:
+            return "Please create a memory palace first."
+        
+        prompt = f"""
+        Provide advanced study tips and memory techniques for this memory palace:
+        
+        PALACE INFO:
+        Content Type: {self.current_palace['content_type']}
+        Difficulty: {self.current_palace['difficulty']}
+        
+        PALACE DESIGN:
+        {self.current_palace['palace_design'][:500]}...
+        
+        Provide:
+        1. Optimal review schedule using spaced repetition
+        2. Advanced memory techniques to strengthen associations
+        3. Ways to expand and connect this palace to other knowledge
+        4. Troubleshooting common memory issues
+        5. Progressive difficulty adjustments
+        6. Multi-sensory enhancement techniques
+        """
+        
+        try:
+            response = self.client.chat.completions.create(
+                model="deepseek/deepseek-r1-0528-qwen3-8b:free",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=800
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Error getting study tips: {str(e)}"
+    
+    def export_palace(self) -> str:
+        """Export current memory palace as JSON"""
+        if not self.current_palace:
+            return "No memory palace to export."
+        
+        return json.dumps(self.current_palace, indent=2)
+
+# Initialize the Memory Palace Builder
+palace_builder = MemoryPalaceBuilder()
+
+# Custom CSS for better styling
+custom_css = """
+.gradio-container {
+    max-width: 1200px !important;
+}
+.palace-header {
+    text-align: center;
+    color: #2c5aa0;
+    margin: 20px 0;
+}
+.section-header {
+    background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 10px;
+    border-radius: 5px;
+    margin: 10px 0;
+}
+"""
+
+# Create the Gradio interface
+with gr.Blocks(css=custom_css, title="Memory Palace Builder", theme=gr.themes.Soft()) as app:
+    gr.HTML("""
+    <div class="palace-header">
+        <h1>🏰 Memory Palace Builder</h1>
+        <p>Transform any space into a powerful learning tool using AI-powered spatial mnemonics</p>
+    </div>
+    """)
+    
+    with gr.Tab("🔑 Setup"):
+        gr.HTML("<div class='section-header'><h3>API Configuration</h3></div>")
+        
+        with gr.Row():
+            api_key_input = gr.Textbox(
+                label="OpenRouter API Key",
+                placeholder="Enter your OpenRouter API key here...",
+                type="password",
+                info="Get your free API key from https://openrouter.ai/"
+            )
+            api_status = gr.Textbox(
+                label="API Status",
+                value="Not connected",
+                interactive=False
+            )
+        
+        validate_btn = gr.Button("🔗 Validate API Key", variant="primary")
+        validate_btn.click(
+            palace_builder.set_api_key,
+            inputs=[api_key_input],
+            outputs=[api_status]
+        )
+    
+    with gr.Tab("🗺️ Space Analysis"):
+        gr.HTML("<div class='section-header'><h3>Describe Your Space</h3></div>")
+        
+        with gr.Row():
+            with gr.Column():
+                space_type = gr.Dropdown(
+                    choices=["Home/Apartment", "Office/Workplace", "School/University", "Neighborhood Route", "Park/Outdoor Space", "Other"],
+                    label="Space Type",
+                    value="Home/Apartment"
+                )
+                
+                space_description = gr.Textbox(
+                    lines=8,
+                    label="Space Description",
+                    placeholder="""Describe your space in detail. For example:
+                    
+'My apartment has a front door that opens to a small hallway. To the left is the living room with a big window, couch, and TV. Straight ahead is the kitchen with white cabinets and a small dining table. The bedroom is to the right with a bed, dresser, and closet. The bathroom is next to the bedroom with a blue shower curtain.'
+
+Include layouts, colors, furniture, lighting, and any distinctive features.""",
+                    info="The more detail you provide, the better your memory palace will be!"
+                )
+            
+            with gr.Column():
+                space_analysis_output = gr.Textbox(
+                    lines=12,
+                    label="Space Analysis",
+                    placeholder="Your space analysis will appear here...",
+                    interactive=False
+                )
+        
+        analyze_btn = gr.Button("🔍 Analyze Space", variant="primary", size="lg")
+        analyze_btn.click(
+            palace_builder.analyze_space,
+            inputs=[space_description, space_type],
+            outputs=[space_analysis_output]
+        )
+    
+    with gr.Tab("🏰 Build Palace"):
+        gr.HTML("<div class='section-header'><h3>Create Your Memory Palace</h3></div>")
+        
+        with gr.Row():
+            with gr.Column():
+                content_type = gr.Dropdown(
+                    choices=["Language Vocabulary", "Historical Facts", "Scientific Concepts", "Programming Code", "Mathematical Formulas", "Medical Terms", "Literature/Poetry", "Business Concepts", "Other"],
+                    label="Content Type",
+                    value="Language Vocabulary"
+                )
+                
+                difficulty = gr.Dropdown(
+                    choices=["Beginner", "Intermediate", "Advanced", "Expert"],
+                    label="Difficulty Level",
+                    value="Intermediate"
+                )
+                
+                learning_content = gr.Textbox(
+                    lines=8,
+                    label="Content to Memorize",
+                    placeholder="""Enter the information you want to memorize. Examples:
+
+For Language: 'French words: maison (house), chat (cat), livre (book), eau (water), rouge (red)'
+
+For History: 'World War II timeline: 1939 - Germany invades Poland, 1941 - Pearl Harbor attack, 1944 - D-Day landings, 1945 - End of war'
+
+For Programming: 'Python list methods: append(), remove(), pop(), insert(), index(), count()'""",
+                    info="Be specific and organized - this will be mapped to your space!"
+                )
+            
+            with gr.Column():
+                palace_output = gr.Textbox(
+                    lines=15,
+                    label="Your Memory Palace",
+                    placeholder="Your custom memory palace will be generated here...",
+                    interactive=False
+                )
+        
+        create_btn = gr.Button("🏗️ Build Memory Palace", variant="primary", size="lg")
+        create_btn.click(
+            palace_builder.create_memory_palace,
+            inputs=[space_analysis_output, learning_content, content_type, difficulty],
+            outputs=[palace_output]
+        )
+    
+    with gr.Tab("📝 Practice & Quiz"):
+        gr.HTML("<div class='section-header'><h3>Test Your Memory Palace</h3></div>")
+        
+        with gr.Row():
+            quiz_type = gr.Dropdown(
+                choices=["Quick Review", "Comprehensive Test", "Spatial Navigation", "Random Recall"],
+                label="Quiz Type",
+                value="Quick Review"
+            )
+            generate_quiz_btn = gr.Button("📋 Generate Quiz", variant="secondary")
+        
+        with gr.Row():
+            with gr.Column():
+                quiz_questions = gr.Textbox(
+                    lines=10,
+                    label="Quiz Questions",
+                    placeholder="Quiz questions will appear here...",
+                    interactive=False
+                )
+            
+            with gr.Column():
+                quiz_answers = gr.Textbox(
+                    lines=10,
+                    label="Answer Key",
+                    placeholder="Answer key will appear here...",
+                    interactive=False
+                )
+        
+        generate_quiz_btn.click(
+            palace_builder.generate_quiz,
+            inputs=[quiz_type],
+            outputs=[quiz_questions, quiz_answers]
+        )
+    
+    with gr.Tab("💡 Study Tips"):
+        gr.HTML("<div class='section-header'><h3>Personalized Learning Strategies</h3></div>")
+        
+        get_tips_btn = gr.Button("🧠 Get Study Tips", variant="secondary", size="lg")
+        
+        study_tips_output = gr.Textbox(
+            lines=15,
+            label="Personalized Study Tips",
+            placeholder="Personalized study strategies will appear here...",
+            interactive=False
+        )
+        
+        get_tips_btn.click(
+            palace_builder.get_study_tips,
+            outputs=[study_tips_output]
+        )
+    
+    with gr.Tab("💾 Export"):
+        gr.HTML("<div class='section-header'><h3>Save Your Memory Palace</h3></div>")
+        
+        export_btn = gr.Button("📤 Export Palace as JSON", variant="secondary")
+        
+        export_output = gr.Code(
+            label="Memory Palace Export",
+            language="json",
+            interactive=False
+        )
+        
+        gr.HTML("""
+        <div style="margin-top: 20px; padding: 15px; background-color: #f0f0f0; border-radius: 5px;">
+            <h4>💡 Tips for Using Your Memory Palace:</h4>
+            <ul>
+                <li><strong>Practice regularly:</strong> Walk through your palace daily for best retention</li>
+                <li><strong>Use multiple senses:</strong> Visualize, hear, and feel the associations</li>
+                <li><strong>Start simple:</strong> Master one palace before creating complex ones</li>
+                <li><strong>Be consistent:</strong> Always follow the same path through your space</li>
+                <li><strong>Make it personal:</strong> Use meaningful locations and vivid imagery</li>
+            </ul>
+        </div>
+        """)
+        
+        export_btn.click(
+            palace_builder.export_palace,
+            outputs=[export_output]
+        )
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch(
+        share=True
+    )