first attempt

README-HF.md

@@ -1,16 +1,19 @@
-# AAC Social Graph Assistant for MND
+# Will's AAC Communication Aid
 
-An Augmentative and Alternative Communication (AAC) system that uses a social graph to provide contextually relevant suggestions for users with Motor Neurone Disease (MND).
+An Augmentative and Alternative Communication (AAC) system that uses a social graph to provide contextually relevant suggestions for Will, a user with Motor Neurone Disease (MND).
 
 ## About
 
-This demo showcases an AAC system that uses a social graph to provide contextually relevant suggestions for users with MND. The system allows users to select who they are talking to and provides suggestions based on the relationship and common topics of conversation, tailored to the British context with NHS healthcare terminology.
+This demo simulates an AAC system from Will's perspective (a 38-year-old with MND). The system allows Will to select who he's talking to, optionally choose a conversation topic, and get appropriate responses based on what the other person has said. All suggestions are tailored to the relationship and conversation context, using British English and NHS healthcare terminology where appropriate.
 
 ## Features
 
-- **Person-Specific Suggestions**: Select who you're talking to and get suggestions tailored to that relationship
+- **Person-Specific Suggestions**: Select who you (Will) are talking to and get tailored responses
+- **Topic Selection**: Choose conversation topics relevant to your relationship
 - **Context-Aware**: Uses a social graph to understand relationships and common topics
-- **Multiple Suggestion Types**: Get suggestions from a language model, common phrases, or predefined utterance categories
+- **Speech Recognition**: Record what others have said to you and have it transcribed
+- **Auto-Detection**: Automatically detect conversation type from what others say
+- **Multiple Response Types**: Get AI-generated responses, common phrases, or category-specific utterances
 - **British Context**: Designed with British English and NHS healthcare context in mind
 - **MND-Specific**: Tailored for the needs of someone with Motor Neurone Disease
 - **Expandable**: Easily improve the system by enhancing the social graph JSON file
@@ -30,12 +33,13 @@ The current social graph represents a British person with MND who:
 
 ## How to Use
 
-1. Select a person from the dropdown menu
-2. View their context information
-3. Optionally enter current conversation context or record audio
-4. If you record audio, click "Transcribe" to convert it to text
-5. Choose a suggestion type
-6. Click "Generate Suggestions" to get contextually relevant phrases
+1. Select who you (Will) are talking to from the dropdown menu
+2. Optionally select a conversation topic
+3. View the relationship context information
+4. Enter what the other person said to you, or record audio
+5. If you record audio, click "Transcribe" to convert it to text
+6. Choose how you want to respond (auto-detect, AI-generated, common phrases, etc.)
+7. Click "Generate My Responses" to get contextually relevant suggestions
 
 ## Customizing the Social Graph
 

README.md

@@ -37,16 +37,31 @@ python app.py
 
 ## How It Works
 
-1. **Social Graph**: The system uses a JSON-based social graph (`social_graph.json`) that contains information about people, their relationships, common topics, and phrases.
+1. **Social Graph**: The system uses a JSON-based social graph (`social_graph.json`) that contains information about:
+   - Will (the AAC user) - a 38-year-old with MND
+   - People in Will's life (family, healthcare providers, friends, colleagues)
+   - Relationships, common topics, and phrases
 
-2. **Context Retrieval**: When you select a person, the system retrieves relevant context information from the social graph.
+2. **Context Retrieval**: When you select who you are (as someone talking to Will), the system retrieves relevant context information from the social graph.
 
-3. **Suggestion Generation**: Based on the selected person and optional conversation context, the system generates suggestions using:
+3. **Conversation Input**: You enter or record what you've said to Will in the conversation.
+
+4. **Suggestion Generation**: Based on who you are and what you've said, the system generates appropriate responses for Will using:
    - A language model (Flan-T5)
-   - Common phrases associated with the person
+   - Common phrases Will might say to you
    - General utterance categories (greetings, needs, emotions, questions)
 
-4. **User Interface**: The Gradio interface provides an intuitive way to interact with the system, select people, and get suggestions.
+5. **User Interface**: The Gradio interface provides an intuitive way to simulate conversations with Will and see what an AAC system might suggest for him to say.
+
+## How to Use
+
+1. Select who you (Will) are talking to from the dropdown menu
+2. Optionally select a conversation topic
+3. View the relationship context information
+4. Enter what the other person said to you, or record audio
+5. If you record audio, click "Transcribe" to convert it to text
+6. Choose how you want to respond (auto-detect, AI-generated, common phrases, etc.)
+7. Click "Generate My Responses" to get contextually relevant suggestions
 
 ## Customizing the Social Graph
 

app.py

@@ -6,14 +6,24 @@ from utils import SocialGraphManager, SuggestionGenerator
 
 # Initialize the social graph manager and suggestion generator
 social_graph = SocialGraphManager("social_graph.json")
-suggestion_generator = SuggestionGenerator()
+
+# Initialize the suggestion generator with distilgpt2
+suggestion_generator = SuggestionGenerator("distilgpt2")
+
+# Test the model to make sure it's working
+test_result = suggestion_generator.test_model()
+print(f"Model test result: {test_result}")
+
+# If the model didn't load, use the fallback responses
+if not suggestion_generator.model_loaded:
+    print("Model failed to load, using fallback responses...")
+    # The SuggestionGenerator class has built-in fallback responses
 
 # Initialize Whisper model (using the smallest model for speed)
 try:
     whisper_model = whisper.load_model("tiny")
     whisper_loaded = True
-except Exception as e:
-    print(f"Warning: Could not load Whisper model: {e}")
+except Exception:
     whisper_loaded = False
 
 
@@ -25,7 +35,22 @@ def format_person_display(person):
 def get_people_choices():
     """Get formatted choices for the people dropdown."""
     people = social_graph.get_people_list()
-    return {format_person_display(person): person["id"] for person in people}
+    choices = {}
+    for person in people:
+        display_name = format_person_display(person)
+        person_id = person["id"]
+        choices[display_name] = person_id
+    return choices
+
+
+def get_topics_for_person(person_id):
+    """Get topics for a specific person."""
+    if not person_id:
+        return []
+
+    person_context = social_graph.get_person_context(person_id)
+    topics = person_context.get("topics", [])
+    return topics
 
 
 def get_suggestion_categories():
@@ -38,49 +63,164 @@ def get_suggestion_categories():
 def on_person_change(person_id):
     """Handle person selection change."""
     if not person_id:
-        return "", ""
+        return "", "", []
 
     person_context = social_graph.get_person_context(person_id)
-    context_info = (
-        f"**{person_context.get('name', '')}** - {person_context.get('role', '')}\n\n"
-    )
-    context_info += f"**Topics:** {', '.join(person_context.get('topics', []))}\n\n"
-    context_info += f"**Frequency:** {person_context.get('frequency', '')}\n\n"
-    context_info += f"**Context:** {person_context.get('context', '')}"
+
+    # Create a more user-friendly context display
+    name = person_context.get("name", "")
+    role = person_context.get("role", "")
+    frequency = person_context.get("frequency", "")
+    context_text = person_context.get("context", "")
+
+    context_info = f"""### I'm talking to: {name}
+**Relationship:** {role}
+**How often we talk:** {frequency}
+
+**Our relationship:** {context_text}
+"""
 
     # Get common phrases for this person
     phrases = person_context.get("common_phrases", [])
     phrases_text = "\n\n".join(phrases)
 
-    return context_info, phrases_text
+    # Get topics for this person
+    topics = person_context.get("topics", [])
 
+    return context_info, phrases_text, topics
 
-def generate_suggestions(person_id, user_input, suggestion_type):
+
+def generate_suggestions(person_id, user_input, suggestion_type, selected_topic=None):
     """Generate suggestions based on the selected person and user input."""
+    print(
+        f"Generating suggestions with: person_id={person_id}, user_input={user_input}, suggestion_type={suggestion_type}, selected_topic={selected_topic}"
+    )
+
     if not person_id:
-        return "Please select a person first."
+        print("No person_id provided")
+        return "Please select who you're talking to first."
 
     person_context = social_graph.get_person_context(person_id)
-
-    # If suggestion type is "model", use the language model
+    print(f"Person context: {person_context}")
+
+    # Try to infer conversation type if user input is provided
+    inferred_category = None
+    if user_input and suggestion_type == "auto_detect":
+        # Simple keyword matching for now - could be enhanced with ML
+        user_input_lower = user_input.lower()
+        if any(
+            word in user_input_lower
+            for word in ["hi", "hello", "morning", "afternoon", "evening"]
+        ):
+            inferred_category = "greetings"
+        elif any(
+            word in user_input_lower
+            for word in ["feel", "tired", "happy", "sad", "frustrated"]
+        ):
+            inferred_category = "emotions"
+        elif any(
+            word in user_input_lower
+            for word in ["need", "want", "help", "water", "toilet", "loo"]
+        ):
+            inferred_category = "needs"
+        elif any(
+            word in user_input_lower
+            for word in ["what", "how", "when", "where", "why", "did"]
+        ):
+            inferred_category = "questions"
+        elif any(
+            word in user_input_lower
+            for word in ["remember", "used to", "back then", "when we"]
+        ):
+            inferred_category = "reminiscing"
+        elif any(
+            word in user_input_lower
+            for word in ["code", "program", "software", "app", "tech"]
+        ):
+            inferred_category = "tech_talk"
+        elif any(
+            word in user_input_lower
+            for word in ["plan", "schedule", "appointment", "tomorrow", "later"]
+        ):
+            inferred_category = "organization"
+
+    # Add topic to context if selected
+    if selected_topic:
+        person_context["selected_topic"] = selected_topic
+
+    # Format the output with multiple suggestions
+    result = ""
+
+    # If suggestion type is "model", use the language model for multiple suggestions
     if suggestion_type == "model":
-        suggestion = suggestion_generator.generate_suggestion(
-            person_context, user_input
-        )
-        return suggestion
+        print("Using model for suggestions")
+        # Generate 3 different suggestions
+        suggestions = []
+        for i in range(3):
+            print(f"Generating suggestion {i+1}/3")
+            try:
+                suggestion = suggestion_generator.generate_suggestion(
+                    person_context, user_input, temperature=0.7
+                )
+                print(f"Generated suggestion: {suggestion}")
+                suggestions.append(suggestion)
+            except Exception as e:
+                print(f"Error generating suggestion: {e}")
+                suggestions.append("Error generating suggestion")
+
+        result = "### AI-Generated Responses:\n\n"
+        for i, suggestion in enumerate(suggestions, 1):
+            result += f"{i}. {suggestion}\n\n"
+
+        print(f"Final result: {result}")
 
     # If suggestion type is "common_phrases", use the person's common phrases
     elif suggestion_type == "common_phrases":
         phrases = social_graph.get_relevant_phrases(person_id, user_input)
-        return "\n\n".join(phrases)
+        result = "### My Common Phrases with this Person:\n\n"
+        for i, phrase in enumerate(phrases, 1):
+            result += f"{i}. {phrase}\n\n"
+
+    # If suggestion type is "auto_detect", use the inferred category or default to model
+    elif suggestion_type == "auto_detect":
+        print(f"Auto-detect mode, inferred category: {inferred_category}")
+        if inferred_category:
+            utterances = social_graph.get_common_utterances(inferred_category)
+            print(f"Got utterances for category {inferred_category}: {utterances}")
+            result = f"### Auto-detected category: {inferred_category.replace('_', ' ').title()}\n\n"
+            for i, utterance in enumerate(utterances, 1):
+                result += f"{i}. {utterance}\n\n"
+        else:
+            print("No category inferred, falling back to model")
+            # Fall back to model if we couldn't infer a category
+            try:
+                suggestion = suggestion_generator.generate_suggestion(
+                    person_context, user_input
+                )
+                print(f"Generated fallback suggestion: {suggestion}")
+                result = "### AI-Generated Response (no category detected):\n\n"
+                result += f"1. {suggestion}\n\n"
+            except Exception as e:
+                print(f"Error generating fallback suggestion: {e}")
+                result = "### Could not generate a response:\n\n"
+                result += "1. Sorry, I couldn't generate a suggestion at this time.\n\n"
 
     # If suggestion type is a category from common_utterances
     elif suggestion_type in get_suggestion_categories():
+        print(f"Using category: {suggestion_type}")
         utterances = social_graph.get_common_utterances(suggestion_type)
-        return "\n\n".join(utterances)
+        print(f"Got utterances: {utterances}")
+        result = f"### {suggestion_type.replace('_', ' ').title()} Phrases:\n\n"
+        for i, utterance in enumerate(utterances, 1):
+            result += f"{i}. {utterance}\n\n"
 
     # Default fallback
-    return "No suggestions available."
+    else:
+        print(f"No handler for suggestion type: {suggestion_type}")
+        result = "No suggestions available. Please try a different option."
+
+    print(f"Returning result: {result[:100]}...")
+    return result
 
 
 def transcribe_audio(audio_path):
@@ -92,40 +232,75 @@ def transcribe_audio(audio_path):
         # Transcribe the audio
         result = whisper_model.transcribe(audio_path)
         return result["text"]
-    except Exception as e:
-        print(f"Error transcribing audio: {e}")
+    except Exception:
         return "Could not transcribe audio. Please try again."
 
 
 # Create the Gradio interface
-with gr.Blocks(title="AAC Social Graph Assistant") as demo:
-    gr.Markdown("# AAC Social Graph Assistant")
+with gr.Blocks(title="Will's AAC Communication Aid") as demo:
+    gr.Markdown("# Will's AAC Communication Aid")
     gr.Markdown(
-        "Select who you're talking to, and get contextually relevant suggestions."
+        """
+    This demo simulates an AAC system from Will's perspective (a 38-year-old with MND).
+
+    **How to use this demo:**
+    1. Select who you (Will) are talking to from the dropdown
+    2. Optionally select a conversation topic
+    3. Enter or record what the other person said to you
+    4. Get suggested responses based on your relationship with that person
+    """
     )
 
+    # Display information about Will
+    with gr.Accordion("About Me (Will)", open=False):
+        gr.Markdown(
+            """
+        I'm Will, a 38-year-old computer programmer from Manchester with MND (diagnosed 5 months ago).
+        I live with my wife Emma and two children (Mabel, 4 and Billy, 7).
+        Originally from South East London, I enjoy technology, Manchester United, and have fond memories of cycling and hiking.
+        I'm increasingly using this AAC system as my speech becomes more difficult.
+        """
+        )
+
     with gr.Row():
         with gr.Column(scale=1):
             # Person selection
             person_dropdown = gr.Dropdown(
-                choices=get_people_choices(), label="Who are you talking to?"
+                choices=get_people_choices(),
+                label="I'm talking to:",
+                info="Select who you (Will) are talking to",
+            )
+
+            # Get topics for the selected person
+            def get_filtered_topics(person_id):
+                if not person_id:
+                    return []
+                person_context = social_graph.get_person_context(person_id)
+                return person_context.get("topics", [])
+
+            # Topic selection dropdown
+            topic_dropdown = gr.Dropdown(
+                choices=[],  # Will be populated when a person is selected
+                label="Topic (optional):",
+                info="Select a topic relevant to this person",
+                allow_custom_value=True,
             )
 
             # Context display
-            context_display = gr.Markdown(label="Context Information")
+            context_display = gr.Markdown(label="Relationship Context")
 
             # User input section
             with gr.Row():
                 user_input = gr.Textbox(
-                    label="Your current conversation (optional)",
-                    placeholder="Type or paste current conversation context here...",
+                    label="What they said to me:",
+                    placeholder='Examples:\n"How was your physio session today?"\n"The kids are asking if you want to watch a movie tonight"\n"I\'ve been looking at that new AAC software you mentioned"',
                     lines=3,
                 )
 
             # Audio input
             with gr.Row():
                 audio_input = gr.Audio(
-                    label="Or record your conversation",
+                    label="Or record what they said:",
                     type="filepath",
                     sources=["microphone"],
                 )
@@ -133,39 +308,56 @@ with gr.Blocks(title="AAC Social Graph Assistant") as demo:
 
             # Suggestion type selection
             suggestion_type = gr.Radio(
-                choices=["model", "common_phrases"] + get_suggestion_categories(),
-                value="model",
-                label="Suggestion Type",
+                choices=[
+                    "auto_detect",
+                    "model",
+                    "common_phrases",
+                ]
+                + get_suggestion_categories(),
+                value="model",  # Default to model for better results
+                label="How should I respond?",
+                info="Choose what kind of responses you want (model = AI-generated)",
             )
 
             # Generate button
-            generate_btn = gr.Button("Generate Suggestions", variant="primary")
+            generate_btn = gr.Button("Generate My Responses", variant="primary")
 
         with gr.Column(scale=1):
             # Common phrases
             common_phrases = gr.Textbox(
-                label="Common Phrases",
-                placeholder="Common phrases will appear here...",
+                label="My Common Phrases",
+                placeholder="Common phrases I often use with this person will appear here...",
                 lines=5,
             )
 
             # Suggestions output
-            suggestions_output = gr.Textbox(
-                label="Suggested Phrases",
-                placeholder="Suggestions will appear here...",
-                lines=8,
+            suggestions_output = gr.Markdown(
+                label="My Suggested Responses",
+                value="Suggested responses will appear here...",
             )
 
     # Set up event handlers
+    def handle_person_change(person_id):
+        """Handle person selection change and update UI elements."""
+        context_info, phrases_text, _ = on_person_change(person_id)
+
+        # Get topics for this person
+        topics = get_filtered_topics(person_id)
+
+        # Update the context, phrases, and topic dropdown
+        return context_info, phrases_text, gr.update(choices=topics)
+
+    # Set up the person change event
     person_dropdown.change(
-        on_person_change,
+        handle_person_change,
         inputs=[person_dropdown],
-        outputs=[context_display, common_phrases],
+        outputs=[context_display, common_phrases, topic_dropdown],
     )
 
+    # Set up the generate button click event
     generate_btn.click(
         generate_suggestions,
-        inputs=[person_dropdown, user_input, suggestion_type],
+        inputs=[person_dropdown, user_input, suggestion_type, topic_dropdown],
         outputs=[suggestions_output],
     )
 

demo.py

@@ -1,27 +1,40 @@
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+from transformers import pipeline
 import json
 
 # Load model
-model_name = "google/flan-t5-base"
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
-rag_pipeline = pipeline("text2text-generation", model=model, tokenizer=tokenizer)
+
+# Use a simpler approach with a pre-built pipeline
+rag_pipeline = pipeline("text-generation", model="distilgpt2")
 
 # Load KG
 with open("social_graph.json", "r") as f:
     kg = json.load(f)
 
 # Build context
-person = kg["people"]["bob"]
-context = f"Bob is the user's son. They talk about football weekly. Last conversation was about coaching changes."
+person = kg["people"]["billy"]  # Using Billy instead of Bob
+context = person["context"]
 
 # User input
-query = "What should I say to Bob?"
+query = "What should I say to Billy?"
 
 # RAG-style prompt
-prompt = f"""Context: {context}
-User wants to say something appropriate to Bob. Suggest a phrase:"""
+prompt = """I am Will, a 38-year-old father with MND (Motor Neuron Disease). I have a 7-year-old son named Billy who loves Manchester United football.
+
+Billy just asked me: "Dad, did you see the United match last night?"
+
+My response to Billy:"""
 
 # Generate
-response = rag_pipeline(prompt, max_length=50)
-print(response[0]["generated_text"])
+response = rag_pipeline(
+    prompt,
+    max_length=100,  # Longer output
+    temperature=0.9,  # More creative
+    do_sample=True,
+    num_return_sequences=1,
+    top_p=0.92,  # More focused sampling
+    top_k=50,  # Limit vocabulary
+)
+print("Generated response:")
+# For text-generation models, we need to extract just the generated part (not the prompt)
+generated_text = response[0]["generated_text"][len(prompt) :]
+print(generated_text)

social_graph.json

@@ -1,4 +1,11 @@
 {
+  "aac_user": {
+    "name": "Will",
+    "age": 38,
+    "location": "Manchester",
+    "background": "Originally from South East London, now living in Manchester with wife Emma and two children (Mabel, 4 and Billy, 7). Diagnosed with MND 5 months ago. Works as a computer programmer with accommodations for condition. Enjoys technology, Manchester United, and has fond memories of cycling and hiking in the Peak District and Lake District. Was active in Scouts growing up.",
+    "communication_needs": "Increasingly using AAC as speech becomes more difficult. Voice banking in progress. Prefers British English expressions and technical terminology when appropriate. When talking to familar people has a tendency to swear but in a friendly way."
+  },
   "people": {
     "emma": {
       "name": "Emma",

utils.py

@@ -3,186 +3,263 @@ import random
 from typing import Dict, List, Any, Optional, Tuple
 from sentence_transformers import SentenceTransformer
 import numpy as np
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+
+from transformers import pipeline
+
 
 class SocialGraphManager:
     """Manages the social graph and provides context for the AAC system."""
-    
+
     def __init__(self, graph_path: str = "social_graph.json"):
         """Initialize the social graph manager.
-        
+
         Args:
             graph_path: Path to the social graph JSON file
         """
         self.graph_path = graph_path
         self.graph = self._load_graph()
-        
+
         # Initialize sentence transformer for semantic matching
         try:
-            self.sentence_model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
+            self.sentence_model = SentenceTransformer(
+                "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+            )
             self.embeddings_cache = {}
             self._initialize_embeddings()
         except Exception as e:
-            print(f"Warning: Could not load sentence transformer model: {e}")
             self.sentence_model = None
-            
+
     def _load_graph(self) -> Dict[str, Any]:
         """Load the social graph from the JSON file."""
         try:
             with open(self.graph_path, "r") as f:
                 return json.load(f)
-        except Exception as e:
-            print(f"Error loading social graph: {e}")
+        except Exception:
             return {"people": {}, "places": [], "topics": []}
-            
+
     def _initialize_embeddings(self):
         """Initialize embeddings for topics and phrases in the social graph."""
         if not self.sentence_model:
             return
-            
+
         # Create embeddings for topics
         topics = self.graph.get("topics", [])
         for topic in topics:
             if topic not in self.embeddings_cache:
                 self.embeddings_cache[topic] = self.sentence_model.encode(topic)
-                
+
         # Create embeddings for common phrases
         for person_id, person_data in self.graph.get("people", {}).items():
             for phrase in person_data.get("common_phrases", []):
                 if phrase not in self.embeddings_cache:
                     self.embeddings_cache[phrase] = self.sentence_model.encode(phrase)
-                    
+
         # Create embeddings for common utterances
         for category, utterances in self.graph.get("common_utterances", {}).items():
             for utterance in utterances:
                 if utterance not in self.embeddings_cache:
-                    self.embeddings_cache[utterance] = self.sentence_model.encode(utterance)
-    
+                    self.embeddings_cache[utterance] = self.sentence_model.encode(
+                        utterance
+                    )
+
     def get_people_list(self) -> List[Dict[str, str]]:
         """Get a list of people from the social graph with their names and roles."""
         people = []
         for person_id, person_data in self.graph.get("people", {}).items():
-            people.append({
-                "id": person_id,
-                "name": person_data.get("name", person_id),
-                "role": person_data.get("role", "")
-            })
+            people.append(
+                {
+                    "id": person_id,
+                    "name": person_data.get("name", person_id),
+                    "role": person_data.get("role", ""),
+                }
+            )
         return people
-    
+
     def get_person_context(self, person_id: str) -> Dict[str, Any]:
         """Get context information for a specific person."""
+        # Check if the person_id contains a display name (e.g., "Emma (wife)")
+        # and try to extract the actual ID
+        if person_id not in self.graph.get("people", {}):
+            # Try to find the person by name
+            for pid, pdata in self.graph.get("people", {}).items():
+                name = pdata.get("name", "")
+                role = pdata.get("role", "")
+                if f"{name} ({role})" == person_id:
+                    person_id = pid
+                    break
+
+        # If still not found, return empty dict
         if person_id not in self.graph.get("people", {}):
             return {}
-            
-        return self.graph["people"][person_id]
-    
-    def get_relevant_phrases(self, person_id: str, user_input: Optional[str] = None) -> List[str]:
+
+        person_data = self.graph["people"][person_id]
+        return person_data
+
+    def get_relevant_phrases(
+        self, person_id: str, user_input: Optional[str] = None
+    ) -> List[str]:
         """Get relevant phrases for a specific person based on user input."""
         if person_id not in self.graph.get("people", {}):
             return []
-            
+
         person_data = self.graph["people"][person_id]
         phrases = person_data.get("common_phrases", [])
-        
+
         # If no user input, return random phrases
         if not user_input or not self.sentence_model:
             return random.sample(phrases, min(3, len(phrases)))
-            
+
         # Use semantic search to find relevant phrases
         user_embedding = self.sentence_model.encode(user_input)
         phrase_scores = []
-        
+
         for phrase in phrases:
             if phrase in self.embeddings_cache:
                 phrase_embedding = self.embeddings_cache[phrase]
             else:
                 phrase_embedding = self.sentence_model.encode(phrase)
                 self.embeddings_cache[phrase] = phrase_embedding
-                
+
             similarity = np.dot(user_embedding, phrase_embedding) / (
                 np.linalg.norm(user_embedding) * np.linalg.norm(phrase_embedding)
             )
             phrase_scores.append((phrase, similarity))
-            
+
         # Sort by similarity score and return top phrases
         phrase_scores.sort(key=lambda x: x[1], reverse=True)
         return [phrase for phrase, _ in phrase_scores[:3]]
-    
+
     def get_common_utterances(self, category: Optional[str] = None) -> List[str]:
         """Get common utterances from the social graph, optionally filtered by category."""
         utterances = []
-        
+
         if "common_utterances" not in self.graph:
             return utterances
-            
+
         if category and category in self.graph["common_utterances"]:
             return self.graph["common_utterances"][category]
-            
+
         # If no category specified, return a sample from each category
         for category_utterances in self.graph["common_utterances"].values():
-            utterances.extend(random.sample(category_utterances, 
-                                           min(2, len(category_utterances))))
-                                           
+            utterances.extend(
+                random.sample(category_utterances, min(2, len(category_utterances)))
+            )
+
         return utterances
 
+
 class SuggestionGenerator:
     """Generates contextual suggestions for the AAC system."""
-    
-    def __init__(self, model_name: str = "google/flan-t5-base"):
+
+    def __init__(self, model_name: str = "distilgpt2"):
         """Initialize the suggestion generator.
-        
+
         Args:
             model_name: Name of the HuggingFace model to use
         """
+        self.model_name = model_name
+        self.model_loaded = False
+
         try:
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-            self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
-            self.generator = pipeline("text2text-generation", 
-                                     model=self.model, 
-                                     tokenizer=self.tokenizer)
+            print(f"Loading model: {model_name}")
+            # Use a simpler approach with a pre-built pipeline
+            self.generator = pipeline("text-generation", model=model_name)
             self.model_loaded = True
+            print(f"Model loaded successfully: {model_name}")
         except Exception as e:
-            print(f"Warning: Could not load model {model_name}: {e}")
+            print(f"Error loading model: {e}")
             self.model_loaded = False
-    
-    def generate_suggestion(self, 
-                           person_context: Dict[str, Any], 
-                           user_input: Optional[str] = None,
-                           max_length: int = 50) -> str:
+
+        # Fallback responses if model fails to load or generate
+        self.fallback_responses = [
+            "I'm not sure how to respond to that.",
+            "That's interesting. Tell me more.",
+            "I'd like to talk about that further.",
+            "I appreciate you sharing that with me.",
+        ]
+
+    def test_model(self) -> str:
+        """Test if the model is working correctly."""
+        if not self.model_loaded:
+            return "Model not loaded"
+
+        try:
+            test_prompt = "I am Will. My son Billy asked about football. I respond:"
+            print(f"Testing model with prompt: {test_prompt}")
+            response = self.generator(test_prompt, max_length=30, do_sample=True)
+            result = response[0]["generated_text"][len(test_prompt) :]
+            print(f"Test response: {result}")
+            return f"Model test successful: {result}"
+        except Exception as e:
+            print(f"Error testing model: {e}")
+            return f"Model test failed: {str(e)}"
+
+    def generate_suggestion(
+        self,
+        person_context: Dict[str, Any],
+        user_input: Optional[str] = None,
+        max_length: int = 50,
+        temperature: float = 0.7,
+    ) -> str:
         """Generate a contextually appropriate suggestion.
-        
+
         Args:
             person_context: Context information about the person
             user_input: Optional user input to consider
             max_length: Maximum length of the generated suggestion
-            
+            temperature: Controls randomness in generation (higher = more random)
+
         Returns:
             A generated suggestion string
         """
         if not self.model_loaded:
-            return "Model not loaded. Please check your installation."
-            
+            # Use fallback responses if model isn't loaded
+            import random
+
+            print("Model not loaded, using fallback responses")
+            return random.choice(self.fallback_responses)
+
         # Extract context information
         name = person_context.get("name", "")
         role = person_context.get("role", "")
         topics = ", ".join(person_context.get("topics", []))
         context = person_context.get("context", "")
-        
+        selected_topic = person_context.get("selected_topic", "")
+
         # Build prompt
-        prompt = f"""Context: {context}
-Person: {name} ({role})
-Topics of interest: {topics}
+        prompt = f"""I am Will, a person with MND (Motor Neuron Disease).
+I'm talking to {name}, who is my {role}.
 """
-        
+
+        if context:
+            prompt += f"Context: {context}\n"
+
+        if topics:
+            prompt += f"Topics of interest: {topics}\n"
+
+        if selected_topic:
+            prompt += f"We're currently talking about: {selected_topic}\n"
+
         if user_input:
-            prompt += f"Current conversation: {user_input}\n"
-            
-        prompt += "Generate an appropriate phrase to say to this person:"
-        
+            prompt += f'\n{name} just said to me: "{user_input}"\n'
+
+        prompt += "\nMy response:"
+
         # Generate suggestion
         try:
-            response = self.generator(prompt, max_length=max_length)
-            return response[0]["generated_text"]
+            print(f"Generating suggestion with prompt: {prompt}")
+            response = self.generator(
+                prompt,
+                max_length=len(prompt.split()) + max_length,
+                temperature=temperature,
+                do_sample=True,
+                top_p=0.92,
+                top_k=50,
+            )
+            # Extract only the generated part, not the prompt
+            result = response[0]["generated_text"][len(prompt) :]
+            print(f"Generated response: {result}")
+            return result.strip()
         except Exception as e:
             print(f"Error generating suggestion: {e}")
             return "Could not generate a suggestion. Please try again."