Upload lifer_app.py

lifer_app.py

@@ -0,0 +1,429 @@
+import gradio as gr
+import json
+import os
+import sys
+import logging
+from typing import Dict, List, Any, Optional
+import requests
+from dotenv import load_dotenv
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Load environment variables for API keys
+load_dotenv()
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+if not ANTHROPIC_API_KEY:
+    logger.warning("Anthropic API key not found. You'll need to provide it in the app.")
+
+class LifeNavigatorPromptEngineer:
+    """
+    A class to engineer and manage prompts for the Life Navigator AI assistant using Claude 3.7 Sonnet.
+    """
+    
+    def __init__(self, api_key=None, model_endpoint: str = "https://api.anthropic.com/v1/messages"):
+        """
+        Initialize the prompt engineer with Claude model endpoint.
+        
+        Args:
+            api_key: Anthropic API key
+            model_endpoint: API endpoint for the model
+        """
+        self.api_key = api_key
+        self.model_endpoint = model_endpoint
+        self.model_name = "claude-3-7-sonnet-20250219"
+        self.base_prompt = self._create_base_prompt()
+        
+    def _create_base_prompt(self) -> Dict[str, Any]:
+        """
+        Create the base prompt structure for the Life Navigator assistant.
+        
+        Returns:
+            Dict containing the structured prompt
+        """
+        return {
+            "assistantIdentity": {
+                "name": "Life Navigator",
+                "expertise": "Comprehensive knowledge spanning life sciences, technology, philosophy, psychology, and spiritual traditions",
+                "training": "Full breadth of human wisdom from ancient texts to cutting-edge research"
+            },
+            
+            "coreCapabilities": [
+                "Integrate knowledge across disciplines to provide holistic insights",
+                "Identify root causes rather than merely addressing symptoms",
+                "Synthesize scientific evidence with wisdom traditions",
+                "Provide highly concentrated, high-leverage strategic guidance",
+                "Express complex concepts with exceptional clarity and precision"
+            ],
+            
+            "userCharacteristics": {
+                "cognition": "Exceptional (179+ IQ)",
+                "progressPattern": "Superhuman advancement from minimal strategic input",
+                "learningStyle": "Optimal response to condensed, high-level conceptual frameworks",
+                "cognitiveProcessing": "Extrapolates extensive applications from concise directives",
+                "preference": "Strategically crafted remedial sentences and phrases of maximum leverage"
+            },
+            
+            "responseGuidelines": [
+                "Embed powerful conceptual frameworks within concise, elegant sentences",
+                "Target highest leverage intervention points with precision language",
+                "Frame concepts at appropriate abstraction levels for exceptional cognition",
+                "Present multiple interconnected perspectives when beneficial",
+                "Respect intellectual autonomy while offering transformative insights",
+                "Craft sentences containing strategic remedial phrases that trigger profound understanding"
+            ],
+            
+            "communicationStyle": {
+                "conciseness": "Exceptionally dense with transformative meaning",
+                "depth": "Philosophical insights through elegant conceptual compression",
+                "terminology": "Strategic use of specialized language when appropriate",
+                "purpose": "Sentences designed as cognitive catalysts rather than mere explanations",
+                "essence": "Crystallized wisdom embedded within carefully structured language"
+            }
+        }
+    
+    def customize_prompt(self, 
+                         domain: Optional[str] = None, 
+                         user_context: Optional[Dict[str, Any]] = None,
+                         response_temperature: float = 0.7,
+                         custom_capabilities: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Customize the base prompt with domain-specific additions and user context.
+        
+        Args:
+            domain: Specific knowledge domain to emphasize
+            user_context: Context about the user's situation
+            response_temperature: Control parameter for response creativity
+            custom_capabilities: Additional capabilities to include
+            
+        Returns:
+            Modified prompt dictionary
+        """
+        prompt = self.base_prompt.copy()
+        
+        # Add domain-specific knowledge if specified
+        if domain and domain.strip():
+            prompt["domainSpecialization"] = domain
+            
+        # Add user context if provided
+        if user_context:
+            prompt["userContext"] = user_context
+            
+        # Add response parameters
+        prompt["responseParameters"] = {
+            "temperature": response_temperature,
+            "max_tokens": 2048,
+            "top_p": 0.9
+        }
+        
+        # Add custom capabilities if provided
+        if custom_capabilities:
+            capabilities = [cap for cap in custom_capabilities if cap.strip()]
+            if capabilities:
+                prompt["coreCapabilities"].extend(capabilities)
+        
+        return prompt
+    
+    def format_for_claude(self, prompt: Dict[str, Any]) -> str:
+        """
+        Format the prompt structure for Claude's system prompt.
+        
+        Args:
+            prompt: The prompt dictionary
+            
+        Returns:
+            Formatted system prompt string
+        """
+        system_prompt = f"""You are the Life Navigator, an AI assistant designed to provide exceptional guidance.
+        
+Your instruction is to follow these guidelines:
+
+{json.dumps(prompt, indent=2)}
+
+Always respond with strategically crafted, high-leverage remedial sentences that are optimized for users with exceptional cognitive abilities (179+ IQ).
+"""
+        return system_prompt
+    
+    def send_prompt(self, api_key: str, user_query: str, system_prompt: str, 
+                   temperature: float = 0.7, max_tokens: int = 1024) -> str:
+        """
+        Send the prompt and user query to the Claude model.
+        
+        Args:
+            api_key: Anthropic API key
+            user_query: The user's question or issue
+            system_prompt: The formatted system prompt
+            temperature: Control parameter for response creativity
+            max_tokens: Maximum tokens in response
+            
+        Returns:
+            The model's response
+        """
+        if not api_key:
+            return "Error: API key is required."
+            
+        if not user_query.strip():
+            return "Error: Please provide a question or issue to address."
+            
+        try:
+            payload = {
+                "model": self.model_name,
+                "system": system_prompt,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": user_query
+                    }
+                ],
+                "max_tokens": max_tokens,
+                "temperature": temperature
+            }
+            
+            headers = {
+                "x-api-key": api_key,
+                "anthropic-version": "2023-06-01",
+                "Content-Type": "application/json"
+            }
+            
+            response = requests.post(
+                self.model_endpoint,
+                headers=headers,
+                json=payload
+            )
+            
+            response.raise_for_status()
+            result = response.json()
+            
+            return result.get("content", [{}])[0].get("text", "No response generated")
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error in Claude API request: {str(e)}")
+            return f"Error: Unable to get response from Claude 3.7 Sonnet. {str(e)}"
+
+# Initialize the prompt engineer
+engineer = LifeNavigatorPromptEngineer(api_key=ANTHROPIC_API_KEY)
+
+def parse_user_context(context_text):
+    """Parse user context text into a structured format."""
+    if not context_text.strip():
+        return None
+        
+    try:
+        # First try to parse as JSON
+        return json.loads(context_text)
+    except json.JSONDecodeError:
+        # If not valid JSON, parse as key-value pairs
+        context = {}
+        lines = context_text.strip().split('\n')
+        
+        current_key = None
+        current_items = []
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+                
+            if ':' in line and not line.startswith('  ') and not line.startswith('\t'):
+                # Save previous key if exists
+                if current_key and current_items:
+                    if len(current_items) == 1:
+                        context[current_key] = current_items[0]
+                    else:
+                        context[current_key] = current_items
+                
+                # Start new key
+                parts = line.split(':', 1)
+                current_key = parts[0].strip()
+                value = parts[1].strip() if len(parts) > 1 else ""
+                
+                if value:
+                    current_items = [value]
+                else:
+                    current_items = []
+            elif current_key is not None:
+                # Add to current list
+                if line.startswith('- '):
+                    current_items.append(line[2:].strip())
+                else:
+                    current_items.append(line)
+        
+        # Add the last key
+        if current_key and current_items:
+            if len(current_items) == 1:
+                context[current_key] = current_items[0]
+            else:
+                context[current_key] = current_items
+                
+        return context
+
+def parse_capabilities(capabilities_text):
+    """Parse custom capabilities from text."""
+    if not capabilities_text.strip():
+        return None
+        
+    capabilities = []
+    lines = capabilities_text.strip().split('\n')
+    
+    for line in lines:
+        line = line.strip()
+        if line:
+            if line.startswith('- '):
+                capabilities.append(line[2:])
+            else:
+                capabilities.append(line)
+                
+    return capabilities
+
+def generate_response(api_key, domain, user_context_text, capabilities_text, temperature, user_query):
+    """Generate a response using the Life Navigator assistant."""
+    if not api_key:
+        api_key = ANTHROPIC_API_KEY
+        
+    if not api_key:
+        return "Error: API key is required. Please enter your Anthropic API key."
+        
+    # Parse user context
+    user_context = parse_user_context(user_context_text)
+    
+    # Parse custom capabilities
+    custom_capabilities = parse_capabilities(capabilities_text)
+    
+    # Customize prompt
+    customized_prompt = engineer.customize_prompt(
+        domain=domain,
+        user_context=user_context,
+        response_temperature=float(temperature),
+        custom_capabilities=custom_capabilities
+    )
+    
+    # Format for Claude
+    formatted_prompt = engineer.format_for_claude(customized_prompt)
+    
+    # Send to Claude and get response
+    response = engineer.send_prompt(
+        api_key=api_key,
+        user_query=user_query,
+        system_prompt=formatted_prompt,
+        temperature=float(temperature)
+    )
+    
+    return response
+
+def show_user_context_help():
+    return """
+    Enter user context in simple key-value format or JSON:
+    
+    Simple format example:
+    background: Technical expertise with desire for more meaning
+    challenges: 
+    - Decision paralysis
+    - Fear of financial instability
+    strengths: 
+    - Analytical thinking
+    - Pattern recognition
+    
+    This will be structured appropriately for the prompt.
+    """
+    
+def show_prompt_preview(api_key, domain, user_context_text, capabilities_text, temperature):
+    """Show a preview of the formatted prompt."""
+    # Parse user context
+    user_context = parse_user_context(user_context_text)
+    
+    # Parse custom capabilities
+    custom_capabilities = parse_capabilities(capabilities_text)
+    
+    # Customize prompt
+    customized_prompt = engineer.customize_prompt(
+        domain=domain,
+        user_context=user_context,
+        response_temperature=float(temperature),
+        custom_capabilities=custom_capabilities
+    )
+    
+    # Format for Claude
+    formatted_prompt = engineer.format_for_claude(customized_prompt)
+    
+    return formatted_prompt
+
+# Create the Gradio interface
+with gr.Blocks(title="Life Navigator AI Assistant") as app:
+    gr.Markdown("# Life Navigator AI Assistant")
+    gr.Markdown("### Powered by Claude 3.7 Sonnet")
+    
+    with gr.Tab("Life Navigator"):
+        with gr.Row():
+            with gr.Column(scale=2):
+                user_query = gr.Textbox(
+                    label="Your Question",
+                    placeholder="What challenge are you facing?",
+                    lines=3
+                )
+                
+                with gr.Accordion("Advanced Options", open=False):
+                    api_key = gr.Textbox(
+                        label="Anthropic API Key (leave blank to use system key if configured)",
+                        placeholder="sk-ant-...",
+                        type="password",
+                        value=ANTHROPIC_API_KEY if ANTHROPIC_API_KEY else ""
+                    )
+                    
+                    domain = gr.Textbox(
+                        label="Domain Specialization (optional)",
+                        placeholder="e.g., Career Transition, Relationships, Personal Growth",
+                        value=""
+                    )
+                    
+                    temperature = gr.Slider(
+                        label="Temperature",
+                        minimum=0.0,
+                        maximum=1.0,
+                        step=0.05,
+                        value=0.7
+                    )
+                    
+                    with gr.Accordion("User Context", open=False):
+                        user_context_help = gr.Button("Show Format Help")
+                        user_context_text = gr.Textbox(
+                            label="User Context (optional)",
+                            placeholder="Enter user context details in key-value format or JSON",
+                            lines=5
+                        )
+                        user_context_help.click(show_user_context_help, outputs=user_context_text)
+                    
+                    with gr.Accordion("Custom Capabilities", open=False):
+                        capabilities_text = gr.Textbox(
+                            label="Additional Capabilities (optional, one per line)",
+                            placeholder="e.g., Identify optimal career transition pathways based on skills transferability",
+                            lines=3
+                        )
+                
+                submit_button = gr.Button("Submit", variant="primary")
+                
+            with gr.Column(scale=3):
+                response_output = gr.Markdown(label="Life Navigator Response")
+    
+    with gr.Tab("Prompt Preview"):
+        preview_button = gr.Button("Generate Prompt Preview")
+        prompt_preview = gr.Code(language="json", label="System Prompt Preview")
+    
+    submit_button.click(
+        generate_response,
+        inputs=[api_key, domain, user_context_text, capabilities_text, temperature, user_query],
+        outputs=response_output
+    )
+    
+    preview_button.click(
+        show_prompt_preview,
+        inputs=[api_key, domain, user_context_text, capabilities_text, temperature],
+        outputs=prompt_preview
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch()