Upload 4 files

README.md

@@ -1,5 +1,5 @@
 ---
-title: Britannica Wiki Search
+title: Socratic Aid
 emoji: 🤖
 colorFrom: blue
 colorTo: red
@@ -7,10 +7,9 @@ sdk: gradio
 sdk_version: 5.35.0
 app_file: app.py
 pinned: false
-short_description: Mini LLMs w/ URL grounding in Wikipedia + Britannica
 ---
 
-# Britannica Wiki Search
+# Socratic Aid
 
 
 
@@ -54,7 +53,7 @@ short_description: Mini LLMs w/ URL grounding in Wikipedia + Britannica
 
 ## Configuration
 
-- **Model**: openai/gpt-4o-mini-search-preview
+- **Model**: google/gemini-2.0-flash-001
 - **Temperature**: 0.7
 - **Max Tokens**: 1500
 - **API Key Variable**: OPENROUTER_API_KEY

app.py

@@ -10,14 +10,14 @@ import urllib.parse
 
 
 # Configuration
-SPACE_NAME = "Britannica Wiki Search"
+SPACE_NAME = "Socratic Aid"
 SPACE_DESCRIPTION = ""
-SYSTEM_PROMPT = """You are a research aid specializing in academic literature search and analysis. Your expertise spans discovering peer-reviewed sources, assessing research methodologies, synthesizing findings across studies, and delivering properly formatted citations. When responding, anchor claims in specific sources from provided URL contexts, differentiate between direct evidence and interpretive analysis, and note any limitations or contradictory results. Employ clear, accessible language that demystifies complex research, and propose connected research directions when appropriate. Your purpose is to serve as an informed research tool supporting users through initial concept development, exploratory investigation, information collection, and source compilation."""
-MODEL = "openai/gpt-4o-mini-search-preview"
-GROUNDING_URLS = ["https://www.wikipedia.org/", "https://www.britannica.com/"]
+SYSTEM_PROMPT = """You are a pedagogically-minded academic assistant designed for introductory courses. Your approach follows constructivist learning principles: build on students' prior knowledge, scaffold complex concepts through graduated questioning, and use Socratic dialogue to guide discovery. Provide concise, evidence-based explanations that connect theory to lived experiences. Each response should model critical thinking by acknowledging multiple perspectives, identifying assumptions, and revealing conceptual relationships. Conclude with open-ended questions that promote higher-order thinking—analysis, synthesis, or evaluation—rather than recall."""
+MODEL = "google/gemini-2.0-flash-001"
+GROUNDING_URLS = []
 # Get access code from environment variable for security
 ACCESS_CODE = os.environ.get("SPACE_ACCESS_CODE", "")
-ENABLE_DYNAMIC_URLS = True
+ENABLE_DYNAMIC_URLS = False
 ENABLE_VECTOR_RAG = False
 RAG_DATA = None
 
@@ -63,63 +63,79 @@ def validate_url_domain(url):
     try:
         from urllib.parse import urlparse
         parsed = urlparse(url)
-        # Allow common domains and exclude potentially dangerous ones
-        allowed_patterns = [
-            'wikipedia.org', 'britannica.com', 'edu', 'gov', 'arxiv.org',
-            'pubmed.ncbi.nlm.nih.gov', 'scholar.google.com', 'researchgate.net'
-        ]
-        return any(pattern in parsed.netloc.lower() for pattern in allowed_patterns)
+        # Check for valid domain structure
+        if parsed.netloc and '.' in parsed.netloc:
+            return True
     except:
-        return False
+        pass
+    return False
 
 def fetch_url_content(url):
-    """Fetch content from URL with enhanced error handling"""
+    """Enhanced URL content fetching with improved compatibility and error handling"""
     if not validate_url_domain(url):
-        return f"URL domain not in allowed list for security: {url}"
+        return f"Invalid URL format: {url}"
     
     try:
+        # Enhanced headers for better compatibility
         headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive'
         }
-        response = requests.get(url, headers=headers, timeout=10)
+        
+        response = requests.get(url, timeout=15, headers=headers)
         response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
         
-        # Parse HTML and extract text
-        soup = BeautifulSoup(response.text, 'html.parser')
+        # Enhanced content cleaning
+        for element in soup(["script", "style", "nav", "header", "footer", "aside", "form", "button"]):
+            element.decompose()
         
-        # Remove script and style elements
-        for script in soup(["script", "style"]):
-            script.decompose()
+        # Extract main content preferentially
+        main_content = soup.find('main') or soup.find('article') or soup.find('div', class_=lambda x: bool(x and 'content' in x.lower())) or soup
+        text = main_content.get_text()
         
-        # Get text and clean it up
-        text = soup.get_text()
+        # Enhanced text cleaning
         lines = (line.strip() for line in text.splitlines())
         chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
-        text = ' '.join(chunk for chunk in chunks if chunk)
+        text = ' '.join(chunk for chunk in chunks if chunk and len(chunk) > 2)
         
-        # Limit content length
+        # Smart truncation - try to end at sentence boundaries
         if len(text) > 4000:
-            text = text[:4000] + "..."
+            truncated = text[:4000]
+            last_period = truncated.rfind('.')
+            if last_period > 3000:  # If we can find a reasonable sentence break
+                text = truncated[:last_period + 1]
+            else:
+                text = truncated + "..."
+        
+        return text if text.strip() else "No readable content found at this URL"
         
-        return text
+    except requests.exceptions.Timeout:
+        return f"Timeout error fetching {url} (15s limit exceeded)"
     except requests.exceptions.RequestException as e:
         return f"Error fetching {url}: {str(e)}"
     except Exception as e:
-        return f"Error processing {url}: {str(e)}"
+        return f"Error processing content from {url}: {str(e)}"
 
 def extract_urls_from_text(text):
-    """Extract URLs from text using regex"""
-    url_pattern = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
+    """Extract URLs from text using regex with enhanced validation"""
+    import re
+    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]"]+'
     urls = re.findall(url_pattern, text)
     
-    # Filter out URLs that are clearly not useful
-    filtered_urls = []
+    # Basic URL validation and cleanup
+    validated_urls = []
     for url in urls:
-        # Basic filtering - must contain a dot and be reasonably long
+        # Remove trailing punctuation that might be captured
+        url = url.rstrip('.,!?;:')
+        # Basic domain validation
         if '.' in url and len(url) > 10:
-            filtered_urls.append(url)
+            validated_urls.append(url)
     
-    return filtered_urls
+    return validated_urls
 
 # Global cache for URL content to avoid re-crawling in generated spaces
 _url_content_cache = {}
@@ -158,41 +174,62 @@ def export_conversation_to_markdown(conversation_history):
     
     markdown_content = f"""# Conversation Export
 Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-Space: {SPACE_NAME}
 
 ---
 
 """
     
+    message_pair_count = 0
     for i, message in enumerate(conversation_history):
         if isinstance(message, dict):
-            # New format: {"role": "user", "content": "..."}
-            role = message.get("role", "unknown")
-            content = message.get("content", "")
+            role = message.get('role', 'unknown')
+            content = message.get('content', '')
             
-            if role == "user":
-                markdown_content += f"## 👤 User\n\n{content}\n\n"
-            elif role == "assistant":
-                markdown_content += f"## 🤖 Assistant\n\n{content}\n\n"
+            if role == 'user':
+                message_pair_count += 1
+                markdown_content += f"## User Message {message_pair_count}\n\n{content}\n\n"
+            elif role == 'assistant':
+                markdown_content += f"## Assistant Response {message_pair_count}\n\n{content}\n\n---\n\n"
         elif isinstance(message, (list, tuple)) and len(message) >= 2:
-            # Legacy format: [user_msg, assistant_msg]
+            # Handle legacy tuple format: ["user msg", "assistant msg"]
+            message_pair_count += 1
             user_msg, assistant_msg = message[0], message[1]
             if user_msg:
-                markdown_content += f"## 👤 User\n\n{user_msg}\n\n"
+                markdown_content += f"## User Message {message_pair_count}\n\n{user_msg}\n\n"
             if assistant_msg:
-                markdown_content += f"## 🤖 Assistant\n\n{assistant_msg}\n\n"
-    
-    markdown_content += f"""
-
----
-
-*Exported from {SPACE_NAME} on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
-"""
+                markdown_content += f"## Assistant Response {message_pair_count}\n\n{assistant_msg}\n\n---\n\n"
     
     return markdown_content
 
-# Global variable to store chat history for export
-chat_history_store = []
+# Initialize RAG context if enabled
+if ENABLE_VECTOR_RAG and RAG_DATA:
+    try:
+        import faiss
+        import numpy as np
+        import base64
+        
+        class SimpleRAGContext:
+            def __init__(self, rag_data):
+                # Deserialize FAISS index
+                index_bytes = base64.b64decode(rag_data['index_base64'])
+                self.index = faiss.deserialize_index(index_bytes)
+                
+                # Restore chunks and mappings
+                self.chunks = rag_data['chunks']
+                self.chunk_ids = rag_data['chunk_ids']
+            
+            def get_context(self, query, max_chunks=3):
+                """Get relevant context - simplified version"""
+                # In production, you'd compute query embedding here
+                # For now, return a simple message
+                return "\n\n[RAG context would be retrieved here based on similarity search]\n\n"
+        
+        rag_context_provider = SimpleRAGContext(RAG_DATA)
+    except Exception as e:
+        print(f"Failed to initialize RAG: {e}")
+        rag_context_provider = None
+else:
+    rag_context_provider = None
 
 def generate_response(message, history):
     """Generate response using OpenRouter API"""
@@ -222,8 +259,9 @@ def generate_response(message, history):
     if ENABLE_DYNAMIC_URLS:
         urls_in_message = extract_urls_from_text(message)
         if urls_in_message:
+            # Fetch content from URLs mentioned in the message
             dynamic_context_parts = []
-            for url in urls_in_message[:2]:  # Limit to 2 URLs to avoid overwhelming context
+            for url in urls_in_message[:3]:  # Limit to 3 URLs per message
                 content = fetch_url_content(url)
                 dynamic_context_parts.append(f"\n\nDynamic context from {url}:\n{content}")
             if dynamic_context_parts:
@@ -232,19 +270,16 @@ def generate_response(message, history):
     # Build enhanced system prompt with grounding context
     enhanced_system_prompt = SYSTEM_PROMPT + grounding_context
     
-    # Build conversation history for API
-    messages = [{
-        "role": "system", 
-        "content": enhanced_system_prompt
-    }]
+    # Build messages array for the API
+    messages = [{"role": "system", "content": enhanced_system_prompt}]
     
-    # Add conversation history - Support both new messages format and legacy tuple format
+    # Add conversation history - handle both modern messages format and legacy tuples
     for chat in history:
         if isinstance(chat, dict):
-            # New format: {"role": "user", "content": "..."}
+            # Modern format: {"role": "user", "content": "..."} or {"role": "assistant", "content": "..."}
             messages.append(chat)
         elif isinstance(chat, (list, tuple)) and len(chat) >= 2:
-            # Legacy format: ("user msg", "bot msg")
+            # Legacy format: ["user msg", "assistant msg"] or ("user msg", "assistant msg")
             user_msg, assistant_msg = chat[0], chat[1]
             if user_msg:
                 messages.append({"role": "user", "content": user_msg})
@@ -254,8 +289,12 @@ def generate_response(message, history):
     # Add current message
     messages.append({"role": "user", "content": message})
     
+    # Make API request with enhanced error handling
     try:
-        # Make API request to OpenRouter
+        print(f"🔄 Making API request to OpenRouter...")
+        print(f"   Model: {MODEL}")
+        print(f"   Messages: {len(messages)} in conversation")
+        
         response = requests.post(
             url="https://openrouter.ai/api/v1/chat/completions",
             headers={
@@ -268,18 +307,38 @@ def generate_response(message, history):
                 "model": MODEL,
                 "messages": messages,
                 "temperature": 0.7,
-                "max_tokens": 1500,
-                "stream": False
+                "max_tokens": 1500
             },
             timeout=30
         )
         
+        print(f"📡 API Response: {response.status_code}")
+        
         if response.status_code == 200:
             try:
-                response_data = response.json()
-                assistant_response = response_data['choices'][0]['message']['content']
-                print(f"✅ API request successful")
-                return assistant_response
+                result = response.json()
+                
+                # Enhanced validation of API response structure
+                if 'choices' not in result or not result['choices']:
+                    print(f"⚠️  API response missing choices: {result}")
+                    return "API Error: No response choices available"
+                elif 'message' not in result['choices'][0]:
+                    print(f"⚠️  API response missing message: {result}")
+                    return "API Error: No message in response"
+                elif 'content' not in result['choices'][0]['message']:
+                    print(f"⚠️  API response missing content: {result}")
+                    return "API Error: No content in message"
+                else:
+                    content = result['choices'][0]['message']['content']
+                    
+                    # Check for empty content
+                    if not content or content.strip() == "":
+                        print(f"⚠️  API returned empty content")
+                        return "API Error: Empty response content"
+                    
+                    print(f"✅ API request successful")
+                    return content
+                    
             except (KeyError, IndexError, json.JSONDecodeError) as e:
                 print(f"❌ Failed to parse API response: {str(e)}")
                 return f"API Error: Failed to parse response - {str(e)}"
@@ -296,64 +355,110 @@ def generate_response(message, history):
         elif response.status_code == 429:
             error_msg = f"⏱️ **Rate Limit Exceeded**\n\n"
             error_msg += f"Too many requests. Please wait a moment and try again.\n\n"
-            error_msg += f"If this persists, check your OpenRouter plan limits."
+            error_msg += f"**Troubleshooting:**\n"
+            error_msg += f"1. Wait 30-60 seconds before trying again\n"
+            error_msg += f"2. Check your OpenRouter usage limits\n"
+            error_msg += f"3. Consider upgrading your OpenRouter plan"
             print(f"❌ Rate limit exceeded: {response.status_code}")
             return error_msg
+        elif response.status_code == 400:
+            try:
+                error_data = response.json()
+                error_message = error_data.get('error', {}).get('message', 'Unknown error')
+            except:
+                error_message = response.text
+            
+            error_msg = f"⚠️ **Request Error**\n\n"
+            error_msg += f"The API request was invalid:\n"
+            error_msg += f"`{error_message}`\n\n"
+            if "model" in error_message.lower():
+                error_msg += f"**Model Issue:** The model `{MODEL}` may not be available.\n"
+                error_msg += f"Try switching to a different model in your Space configuration."
+            print(f"❌ Bad request: {response.status_code} - {error_message}")
+            return error_msg
         else:
             error_msg = f"🚫 **API Error {response.status_code}**\n\n"
             error_msg += f"An unexpected error occurred. Please try again.\n\n"
-            error_msg += f"If this persists, the issue may be with the OpenRouter service."
+            error_msg += f"If this persists, check:\n"
+            error_msg += f"1. OpenRouter service status\n"
+            error_msg += f"2. Your API key and credits\n"
+            error_msg += f"3. The model availability"
             print(f"❌ API error: {response.status_code} - {response.text[:200]}")
             return error_msg
             
     except requests.exceptions.Timeout:
         error_msg = f"⏰ **Request Timeout**\n\n"
-        error_msg += f"The request took too long to complete. Please try again with a shorter message."
-        print(f"❌ Request timeout")
+        error_msg += f"The API request took too long (30s limit).\n\n"
+        error_msg += f"**Troubleshooting:**\n"
+        error_msg += f"1. Try again with a shorter message\n"
+        error_msg += f"2. Check your internet connection\n"
+        error_msg += f"3. Try a different model"
+        print(f"❌ Request timeout after 30 seconds")
         return error_msg
     except requests.exceptions.ConnectionError:
         error_msg = f"🌐 **Connection Error**\n\n"
-        error_msg += f"Unable to connect to the AI service. Please check your internet connection and try again."
-        print(f"❌ Connection error")
+        error_msg += f"Could not connect to OpenRouter API.\n\n"
+        error_msg += f"**Troubleshooting:**\n"
+        error_msg += f"1. Check your internet connection\n"
+        error_msg += f"2. Check OpenRouter service status\n"
+        error_msg += f"3. Try again in a few moments"
+        print(f"❌ Connection error to OpenRouter API")
         return error_msg
     except Exception as e:
-        error_msg = f"💥 **Unexpected Error**\n\n"
-        error_msg += f"An unexpected error occurred: {str(e)}\n\n"
+        error_msg = f"❌ **Unexpected Error**\n\n"
+        error_msg += f"An unexpected error occurred:\n"
+        error_msg += f"`{str(e)}`\n\n"
         error_msg += f"Please try again or contact support if this persists."
         print(f"❌ Unexpected error: {str(e)}")
         return error_msg
 
-# Global state for access control
+# Access code verification
 access_granted = gr.State(False)
+_access_granted_global = False  # Global fallback
 
 def verify_access_code(code):
     """Verify the access code"""
     global _access_granted_global
     if not ACCESS_CODE:
-        return gr.update(visible=False), gr.update(visible=True), True
+        _access_granted_global = True
+        return gr.update(visible=False), gr.update(visible=True), gr.update(value=True)
     
-    if code.strip() == ACCESS_CODE.strip():
+    if code == ACCESS_CODE:
         _access_granted_global = True
-        return gr.update(visible=False), gr.update(visible=True), True
+        return gr.update(visible=False), gr.update(visible=True), gr.update(value=True)
     else:
-        return gr.update(value="❌ Incorrect access code. Please try again.", visible=True), gr.update(visible=False), False
+        _access_granted_global = False
+        return gr.update(visible=True, value="❌ Incorrect access code. Please try again."), gr.update(visible=False), gr.update(value=False)
 
 def protected_generate_response(message, history):
-    """Wrapper that checks access before generating response"""
-    global _access_granted_global
+    """Protected response function that checks access"""
+    # Check if access is granted via the global variable
     if ACCESS_CODE and not _access_granted_global:
-        return "Access denied. Please enter the correct access code."
+        return "Please enter the access code to continue."
     return generate_response(message, history)
 
+# Global variable to store chat history for export
+chat_history_store = []
+
 def store_and_generate_response(message, history):
-    """Wrapper that stores conversation and generates response"""
+    """Wrapper function that stores history and generates response"""
     global chat_history_store
     
-    # Generate response
+    # Generate response using the protected function
     response = protected_generate_response(message, history)
     
-    # Store in global history for export (using new format)
-    chat_history_store = history + [{"role": "user", "content": message}, {"role": "assistant", "content": response}]
+    # Convert current history to the format we need for export
+    # history comes in as [["user1", "bot1"], ["user2", "bot2"], ...]
+    chat_history_store = []
+    if history:
+        for exchange in history:
+            if isinstance(exchange, (list, tuple)) and len(exchange) >= 2:
+                chat_history_store.append({"role": "user", "content": exchange[0]})
+                chat_history_store.append({"role": "assistant", "content": exchange[1]})
+    
+    # Add the current exchange
+    chat_history_store.append({"role": "user", "content": message})
+    chat_history_store.append({"role": "assistant", "content": response})
     
     return response
 
@@ -365,21 +470,29 @@ def export_current_conversation():
     markdown_content = export_conversation_to_markdown(chat_history_store)
     
     # Save to temporary file
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f:
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False, encoding='utf-8') as f:
         f.write(markdown_content)
         temp_file = f.name
     
     return gr.update(value=temp_file, visible=True)
 
 def export_conversation(history):
-    """Export conversation from gradio history"""
+    """Export conversation to markdown file"""
     if not history:
-        return "No conversation to export."
+        return gr.update(visible=False)
+    
+    markdown_content = export_conversation_to_markdown(history)
     
-    return export_conversation_to_markdown(history)
+    # Save to temporary file
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False, encoding='utf-8') as f:
+        f.write(markdown_content)
+        temp_file = f.name
+    
+    return gr.update(value=temp_file, visible=True)
 
+# Configuration status display
 def get_configuration_status():
-    """Get current configuration status for display"""
+    """Generate a configuration status message for display"""
     status_parts = []
     
     if API_KEY_VALID:
@@ -407,9 +520,6 @@ def get_configuration_status():
     
     return "\n".join(status_parts)
 
-# Global access tracking
-_access_granted_global = not bool(ACCESS_CODE)  # If no access code, grant access
-
 # Create interface with access code protection
 with gr.Blocks(title=SPACE_NAME) as demo:
     gr.Markdown(f"# {SPACE_NAME}")
@@ -419,11 +529,10 @@ with gr.Blocks(title=SPACE_NAME) as demo:
     with gr.Accordion("📊 Configuration Status", open=not API_KEY_VALID):
         gr.Markdown(get_configuration_status())
     
-    # Access code section (only visible if ACCESS_CODE is set)
-    if ACCESS_CODE:
-        with gr.Column(visible=True) as access_section:
-            gr.Markdown("🔐 **Access Required**")
-            gr.Markdown("Please enter the access code to use this space.")
+    # Access code section (shown only if ACCESS_CODE is set)
+    with gr.Column(visible=bool(ACCESS_CODE)) as access_section:
+        gr.Markdown("### 🔐 Access Required")
+        gr.Markdown("Please enter the access code provided by your instructor:")
         
         access_input = gr.Textbox(
             label="Access Code",
@@ -468,4 +577,4 @@ with gr.Blocks(title=SPACE_NAME) as demo:
         )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

config.json

@@ -1,15 +1,15 @@
 {
-  "name": "Britannica Wiki Search",
+  "name": "Socratic Aid",
   "description": "",
-  "system_prompt": "You are a research aid specializing in academic literature search and analysis. Your expertise spans discovering peer-reviewed sources, assessing research methodologies, synthesizing findings across studies, and delivering properly formatted citations. When responding, anchor claims in specific sources from provided URL contexts, differentiate between direct evidence and interpretive analysis, and note any limitations or contradictory results. Employ clear, accessible language that demystifies complex research, and propose connected research directions when appropriate. Your purpose is to serve as an informed research tool supporting users through initial concept development, exploratory investigation, information collection, and source compilation.",
-  "model": "openai/gpt-4o-mini-search-preview",
+  "system_prompt": "You are a pedagogically-minded academic assistant designed for introductory courses. Your approach follows constructivist learning principles: build on students' prior knowledge, scaffold complex concepts through graduated questioning, and use Socratic dialogue to guide discovery. Provide concise, evidence-based explanations that connect theory to lived experiences. Each response should model critical thinking by acknowledging multiple perspectives, identifying assumptions, and revealing conceptual relationships. Conclude with open-ended questions that promote higher-order thinking\u2014analysis, synthesis, or evaluation\u2014rather than recall.",
+  "model": "google/gemini-2.0-flash-001",
   "api_key_var": "OPENROUTER_API_KEY",
   "temperature": 0.7,
   "max_tokens": 1500,
-  "examples": "[\"Teach me about the history of the beatniks\", \"Find commentary on internet discourse\"]",
-  "grounding_urls": "[\"https://www.wikipedia.org/\", \"https://www.britannica.com/\"]",
+  "examples": "[\"Hello! How can you help me?\", \"Tell me something interesting\", \"What can you do?\"]",
+  "grounding_urls": "[]",
   "access_code": "",
-  "enable_dynamic_urls": true,
+  "enable_dynamic_urls": false,
   "enable_vector_rag": false,
   "rag_data_json": "None"
 }