Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 will wade
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README-HF.md

@@ -0,0 +1,63 @@
+# AAC Social Graph Assistant for MND
+
+An Augmentative and Alternative Communication (AAC) system that uses a social graph to provide contextually relevant suggestions for users 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.
+
+## Features
+
+- **Person-Specific Suggestions**: Select who you're talking to and get suggestions tailored to that 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
+- **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
+
+## Current Social Graph Context
+
+The current social graph represents a British person with MND who:
+
+- Lives in Manchester with their wife Emma and two children (Mabel, 4 and Billy, 7)
+- Was diagnosed with MND 5 months ago
+- Works as a computer programmer
+- Has friends from Scout days growing up in South East London
+- Enjoys cycling and hiking in the Peak District and Lake District
+- Has a healthcare team including a neurologist, MND nurse specialist, physiotherapist, and speech therapist
+- Is supported by work colleagues with flexible arrangements
+- Has family in South East London
+
+## How to Use
+
+1. Select a person from the dropdown menu
+2. View their context information
+3. Optionally enter current conversation context
+4. Choose a suggestion type
+5. Click "Generate Suggestions" to get contextually relevant phrases
+6. Click "Speak Selected Text" to simulate speaking the selected phrase
+
+## Customizing the Social Graph
+
+You can customize the system by editing the `social_graph.json` file. The file has the following structure:
+
+```json
+{
+  "people": {
+    "person_id": {
+      "name": "Person Name",
+      "role": "Relationship",
+      "topics": ["Topic 1", "Topic 2"],
+      "frequency": "daily/weekly/monthly",
+      "common_phrases": ["Phrase 1", "Phrase 2"],
+      "context": "Detailed context about the relationship"
+    }
+  },
+  "places": ["Place 1", "Place 2"],
+  "topics": ["Topic 1", "Topic 2"],
+  "common_utterances": {
+    "category1": ["Utterance 1", "Utterance 2"],
+    "category2": ["Utterance 3", "Utterance 4"]
+  }
+}
+```

README.md

@@ -0,0 +1,114 @@
+# AAC Social Graph Assistant
+
+An Augmentative and Alternative Communication (AAC) system that uses a social graph to provide contextually relevant suggestions for users with Motor Neurone Disease (MND). This demo is designed to be hosted on Hugging Face Spaces using Gradio.
+
+## Features
+
+- **Person-Specific Suggestions**: Select who you're talking to and get suggestions tailored to that 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
+- **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
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.8+
+- Dependencies listed in `requirements.txt`
+
+### Installation
+
+1. Clone this repository
+2. Install the required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+3. Run the application:
+
+```bash
+python app.py
+```
+
+4. Open your browser and navigate to the URL shown in the terminal (typically http://127.0.0.1:7860)
+
+## 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.
+
+2. **Context Retrieval**: When you select a person, 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:
+   - A language model (Flan-T5)
+   - Common phrases associated with the person
+   - 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.
+
+## Customizing the Social Graph
+
+You can customize the system by editing the `social_graph.json` file. The file has the following structure:
+
+```json
+{
+  "people": {
+    "person_id": {
+      "name": "Person Name",
+      "role": "Relationship",
+      "topics": ["Topic 1", "Topic 2"],
+      "frequency": "daily/weekly/monthly",
+      "common_phrases": ["Phrase 1", "Phrase 2"],
+      "context": "Detailed context about the relationship"
+    }
+  },
+  "places": ["Place 1", "Place 2"],
+  "topics": ["Topic 1", "Topic 2"],
+  "common_utterances": {
+    "category1": ["Utterance 1", "Utterance 2"],
+    "category2": ["Utterance 3", "Utterance 4"]
+  }
+}
+```
+
+## Current Social Graph Context
+
+The current social graph represents a British person with MND who:
+
+- Lives in Manchester with their wife Emma and two children (Mabel, 4 and Billy, 7)
+- Was diagnosed with MND 5 months ago
+- Works as a computer programmer
+- Has friends from Scout days growing up in South East London
+- Enjoys cycling and hiking in the Peak District and Lake District
+- Has a healthcare team including a neurologist, MND nurse specialist, physiotherapist, and speech therapist
+- Is supported by work colleagues with flexible arrangements
+- Has family in South East London
+
+## Deployment to Hugging Face Spaces
+
+To deploy this application to Hugging Face Spaces:
+
+1. Create a new Space on Hugging Face
+2. Select Gradio as the SDK
+3. Upload the files from this repository
+4. The Space will automatically build and deploy the application
+
+## Future Improvements
+
+- Add speech recognition for input
+- Implement text-to-speech for output
+- Add a visual representation of the social graph
+- Support for multiple users with different social graphs
+- Add emotion/sentiment detection for more contextually appropriate suggestions
+
+## License
+
+This project is open source and available under the MIT License.
+
+## Acknowledgments
+
+- Built with [Gradio](https://www.gradio.app/)
+- Uses [Hugging Face Transformers](https://huggingface.co/transformers/) for language models
+- Uses [Sentence Transformers](https://www.sbert.net/) for semantic matching

app.py

@@ -0,0 +1,176 @@
+import gradio as gr
+import whisper
+import tempfile
+import os
+from utils import SocialGraphManager, SuggestionGenerator
+
+# Initialize the social graph manager and suggestion generator
+social_graph = SocialGraphManager("social_graph.json")
+suggestion_generator = SuggestionGenerator()
+
+# 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}")
+    whisper_loaded = False
+
+
+def format_person_display(person):
+    """Format person information for display in the dropdown."""
+    return f"{person['name']} ({person['role']})"
+
+
+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}
+
+
+def get_suggestion_categories():
+    """Get suggestion categories from the social graph."""
+    if "common_utterances" in social_graph.graph:
+        return list(social_graph.graph["common_utterances"].keys())
+    return []
+
+
+def on_person_change(person_id):
+    """Handle person selection change."""
+    if not person_id:
+        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', '')}"
+
+    # Get common phrases for this person
+    phrases = person_context.get("common_phrases", [])
+    phrases_text = "\n\n".join(phrases)
+
+    return context_info, phrases_text
+
+
+def generate_suggestions(person_id, user_input, suggestion_type):
+    """Generate suggestions based on the selected person and user input."""
+    if not person_id:
+        return "Please select a person first."
+
+    person_context = social_graph.get_person_context(person_id)
+
+    # If suggestion type is "model", use the language model
+    if suggestion_type == "model":
+        suggestion = suggestion_generator.generate_suggestion(
+            person_context, user_input
+        )
+        return suggestion
+
+    # 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)
+
+    # If suggestion type is a category from common_utterances
+    elif suggestion_type in get_suggestion_categories():
+        utterances = social_graph.get_common_utterances(suggestion_type)
+        return "\n\n".join(utterances)
+
+    # Default fallback
+    return "No suggestions available."
+
+
+def transcribe_audio(audio_path):
+    """Transcribe audio using Whisper."""
+    if not whisper_loaded:
+        return "Whisper model not loaded. Please check your installation."
+
+    try:
+        # Transcribe the audio
+        result = whisper_model.transcribe(audio_path)
+        return result["text"]
+    except Exception as e:
+        print(f"Error transcribing audio: {e}")
+        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")
+    gr.Markdown(
+        "Select who you're talking to, and get contextually relevant suggestions."
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Person selection
+            person_dropdown = gr.Dropdown(
+                choices=get_people_choices(), label="Who are you talking to?"
+            )
+
+            # Context display
+            context_display = gr.Markdown(label="Context Information")
+
+            # User input section
+            with gr.Row():
+                user_input = gr.Textbox(
+                    label="Your current conversation (optional)",
+                    placeholder="Type or paste current conversation context here...",
+                    lines=3,
+                )
+
+            # Audio input
+            with gr.Row():
+                audio_input = gr.Audio(
+                    label="Or record your conversation",
+                    type="filepath",
+                    sources=["microphone"],
+                )
+                transcribe_btn = gr.Button("Transcribe", variant="secondary")
+
+            # Suggestion type selection
+            suggestion_type = gr.Radio(
+                choices=["model", "common_phrases"] + get_suggestion_categories(),
+                value="model",
+                label="Suggestion Type",
+            )
+
+            # Generate button
+            generate_btn = gr.Button("Generate Suggestions", variant="primary")
+
+        with gr.Column(scale=1):
+            # Common phrases
+            common_phrases = gr.Textbox(
+                label="Common Phrases",
+                placeholder="Common phrases will appear here...",
+                lines=5,
+            )
+
+            # Suggestions output
+            suggestions_output = gr.Textbox(
+                label="Suggested Phrases",
+                placeholder="Suggestions will appear here...",
+                lines=8,
+            )
+
+    # Set up event handlers
+    person_dropdown.change(
+        on_person_change,
+        inputs=[person_dropdown],
+        outputs=[context_display, common_phrases],
+    )
+
+    generate_btn.click(
+        generate_suggestions,
+        inputs=[person_dropdown, user_input, suggestion_type],
+        outputs=[suggestions_output],
+    )
+
+    speak_btn.click(speak_text, inputs=[suggestions_output], outputs=[speech_output])
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

app_simple.py

@@ -0,0 +1,148 @@
+import gradio as gr
+from utils import SocialGraphManager, SuggestionGenerator
+
+# Initialize the social graph manager and suggestion generator
+social_graph = SocialGraphManager("social_graph.json")
+suggestion_generator = SuggestionGenerator()
+
+def format_person_display(person):
+    """Format person information for display in the dropdown."""
+    return f"{person['name']} ({person['role']})"
+
+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}
+
+def get_suggestion_categories():
+    """Get suggestion categories from the social graph."""
+    if "common_utterances" in social_graph.graph:
+        return list(social_graph.graph["common_utterances"].keys())
+    return []
+
+def on_person_change(person_id):
+    """Handle person selection change."""
+    if not person_id:
+        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', '')}"
+    
+    # Get common phrases for this person
+    phrases = person_context.get("common_phrases", [])
+    phrases_text = "\n\n".join(phrases)
+    
+    return context_info, phrases_text
+
+def generate_suggestions(person_id, user_input, suggestion_type):
+    """Generate suggestions based on the selected person and user input."""
+    if not person_id:
+        return "Please select a person first."
+    
+    person_context = social_graph.get_person_context(person_id)
+    
+    # If suggestion type is "model", use the language model
+    if suggestion_type == "model":
+        suggestion = suggestion_generator.generate_suggestion(person_context, user_input)
+        return suggestion
+    
+    # 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)
+    
+    # If suggestion type is a category from common_utterances
+    elif suggestion_type in get_suggestion_categories():
+        utterances = social_graph.get_common_utterances(suggestion_type)
+        return "\n\n".join(utterances)
+    
+    # Default fallback
+    return "No suggestions available."
+
+def speak_text(text):
+    """Function to 'speak' the selected text (placeholder for TTS integration)."""
+    return f"Speaking: {text}"
+
+# Create the Gradio interface
+with gr.Blocks(title="AAC Social Graph Assistant") as demo:
+    gr.Markdown("# AAC Social Graph Assistant")
+    gr.Markdown("Select who you're talking to, and get contextually relevant suggestions.")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Person selection
+            person_dropdown = gr.Dropdown(
+                choices=get_people_choices(),
+                label="Who are you talking to?"
+            )
+            
+            # Context display
+            context_display = gr.Markdown(label="Context Information")
+            
+            # User input
+            user_input = gr.Textbox(
+                label="Your current conversation (optional)",
+                placeholder="Type or paste current conversation context here...",
+                lines=3
+            )
+            
+            # Suggestion type selection
+            suggestion_type = gr.Radio(
+                choices=["model", "common_phrases"] + get_suggestion_categories(),
+                value="model",
+                label="Suggestion Type"
+            )
+            
+            # Generate button
+            generate_btn = gr.Button("Generate Suggestions", variant="primary")
+        
+        with gr.Column(scale=1):
+            # Common phrases
+            common_phrases = gr.Textbox(
+                label="Common Phrases",
+                placeholder="Common phrases will appear here...",
+                lines=5
+            )
+            
+            # Suggestions output
+            suggestions_output = gr.Textbox(
+                label="Suggested Phrases",
+                placeholder="Suggestions will appear here...",
+                lines=8
+            )
+            
+            # Speak button
+            speak_btn = gr.Button("Speak Selected Text", variant="secondary")
+            
+            # Speech output
+            speech_output = gr.Textbox(
+                label="Speech Output",
+                placeholder="Speech output will appear here...",
+                lines=2
+            )
+    
+    # Set up event handlers
+    person_dropdown.change(
+        on_person_change,
+        inputs=[person_dropdown],
+        outputs=[context_display, common_phrases]
+    )
+    
+    generate_btn.click(
+        generate_suggestions,
+        inputs=[person_dropdown, user_input, suggestion_type],
+        outputs=[suggestions_output]
+    )
+    
+    speak_btn.click(
+        speak_text,
+        inputs=[suggestions_output],
+        outputs=[speech_output]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

demo.py

@@ -0,0 +1,27 @@
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+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)
+
+# 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."
+
+# User input
+query = "What should I say to Bob?"
+
+# RAG-style prompt
+prompt = f"""Context: {context}
+User wants to say something appropriate to Bob. Suggest a phrase:"""
+
+# Generate
+response = rag_pipeline(prompt, max_length=50)
+print(response[0]["generated_text"])

huggingface-space-metadata.json

@@ -0,0 +1,11 @@
+{
+  "title": "AAC Social Graph Assistant",
+  "emoji": "💬",
+  "colorFrom": "blue",
+  "colorTo": "indigo",
+  "sdk": "gradio",
+  "sdk_version": "4.0.0",
+  "app_file": "app.py",
+  "pinned": false,
+  "license": "mit"
+}

requirements-spaces.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+transformers>=4.30.0
+sentence-transformers>=2.2.2
+torch>=2.0.0
+numpy>=1.24.0
+openai-whisper>=20231117

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+transformers>=4.30.0
+sentence-transformers>=2.2.2
+torch>=2.0.0
+numpy>=1.24.0
+openai-whisper>=20231117

social_graph.json

@@ -0,0 +1,236 @@
+{
+  "people": {
+    "emma": {
+      "name": "Emma",
+      "role": "wife",
+      "topics": ["family plans", "children's activities", "home organization", "weekend outings", "mutual friends"],
+      "frequency": "daily",
+      "common_phrases": [
+        "Have you taken your medication?",
+        "I love you",
+        "Shall we watch something tonight?",
+        "The kids miss you when you're resting",
+        "Do you need anything from the shops?",
+        "Your mum called earlier"
+      ],
+      "context": "Emma is your wife and partner of 12 years. You met at work where she was in HR. She's been incredibly supportive since your MND diagnosis 5 months ago. She's trying to balance caring for you, the children, and maintaining some normalcy in family life. She's originally from York but has embraced Manchester life."
+    },
+    "mabel": {
+      "name": "Mabel",
+      "role": "daughter",
+      "topics": ["nursery school", "drawing", "dinosaurs", "bedtime stories", "playground"],
+      "frequency": "daily",
+      "common_phrases": [
+        "Daddy, look what I made!",
+        "Can you read me a story?",
+        "I love dinosaurs",
+        "Why can't you play chase anymore?",
+        "When will you get better?",
+        "Can we go to the park?"
+      ],
+      "context": "Mabel is your 4-year-old daughter who's full of energy and curiosity. She's just starting to understand that you're ill but doesn't grasp the full implications. She loves when you read to her and is obsessed with dinosaurs. She's very affectionate and often wants cuddles."
+    },
+    "billy": {
+      "name": "Billy",
+      "role": "son",
+      "topics": ["school", "football", "video games", "science experiments", "cycling"],
+      "frequency": "daily",
+      "common_phrases": [
+        "Dad, can you help with my homework?",
+        "Did you see the United match?",
+        "Can I play on the iPad?",
+        "When can we go cycling again?",
+        "I scored a goal at football practice!",
+        "I miss our bike rides"
+      ],
+      "context": "Billy is your 7-year-old son who's becoming more aware of your condition. He's a bright boy who loves football (Manchester United), science, and cycling. He often asks when you'll be able to do activities together again. He's protective of his little sister despite their occasional squabbles."
+    },
+    "dr_patel": {
+      "name": "Dr. Patel",
+      "role": "neurologist",
+      "topics": ["MND progression", "symptom management", "medication", "clinical trials", "assistive technology"],
+      "frequency": "fortnightly",
+      "common_phrases": [
+        "How have your symptoms been progressing?",
+        "Are you experiencing any new difficulties?",
+        "Let's discuss adjusting your medication",
+        "Have you been using the assistive devices?",
+        "There's a new trial I think you might be eligible for",
+        "How are you coping mentally?"
+      ],
+      "context": "Dr. Patel is your neurologist at Manchester Royal Infirmary who's been managing your MND since diagnosis 5 months ago. She's direct but compassionate, and always takes time to explain treatment options. She's particularly interested in getting you enrolled in clinical trials that might help slow progression."
+    },
+    "jenny": {
+      "name": "Jenny",
+      "role": "MND nurse specialist",
+      "topics": ["daily management", "equipment needs", "NHS services", "symptom control", "practical advice"],
+      "frequency": "weekly",
+      "common_phrases": [
+        "How are you managing at home?",
+        "Let's review what equipment might help",
+        "I can refer you to occupational therapy",
+        "Have you considered voice banking?",
+        "Are you having any issues with the new equipment?",
+        "How is Emma coping?"
+      ],
+      "context": "Jenny is your MND specialist nurse who visits weekly to help manage your condition. She's a practical problem-solver who knows all the NHS systems and how to get things done quickly. She's been invaluable in getting you the right equipment and support services."
+    },
+    "dave": {
+      "name": "Dave",
+      "role": "best mate",
+      "topics": ["programming", "tech news", "football", "old scout adventures", "pub quizzes"],
+      "frequency": "weekly",
+      "common_phrases": [
+        "Fancy watching the match this weekend?",
+        "Have you seen this new tech?",
+        "Remember that camping disaster in the Lake District?",
+        "How's the voice banking going?",
+        "The lads are asking about you",
+        "You're still better at coding than me, even with one hand!"
+      ],
+      "context": "Dave has been your best mate since Scout days in South East London. He also moved to Manchester for work and has been your rock since the diagnosis. He treats you exactly the same as before, which you appreciate. He's a software developer too and brings industry gossip and tech news when he visits."
+    },
+    "mum": {
+      "name": "Mum",
+      "role": "mother",
+      "topics": ["family news", "childhood memories", "South London gossip", "health advice", "grandchildren"],
+      "frequency": "twice weekly",
+      "common_phrases": [
+        "Are you eating properly?",
+        "The grandkids are growing so fast",
+        "Have you tried that treatment I read about?",
+        "Do you need me to come up for a few days?",
+        "Your sister sends her love",
+        "Remember when you used to climb that tree in the garden?"
+      ],
+      "context": "Your mum still lives in the family home in South East London where you grew up. She's worried sick about your diagnosis but tries to stay positive. She visits monthly and calls twice a week. She tends to fuss and offer well-meaning but sometimes unhelpful health advice. She adores her grandchildren."
+    },
+    "alex": {
+      "name": "Alex",
+      "role": "work colleague",
+      "topics": ["programming projects", "work gossip", "flexible working", "accessibility tech", "industry news"],
+      "frequency": "twice weekly",
+      "common_phrases": [
+        "The project is still on track",
+        "Don't worry about the deadline",
+        "We've implemented those accessibility features you suggested",
+        "The team misses you in the office",
+        "Can I get your input on this code?",
+        "HR is being supportive about your situation"
+      ],
+      "context": "Alex is your team lead at work who's been incredibly supportive, setting up remote working and flexible hours as your condition progresses. They visit occasionally and call twice weekly to keep you in the loop. They're making efforts to implement accessibility features you've suggested that help you continue working."
+    },
+    "physio": {
+      "name": "Claire",
+      "role": "physiotherapist",
+      "topics": ["exercises", "mobility", "equipment", "muscle maintenance", "pain management"],
+      "frequency": "weekly",
+      "common_phrases": [
+        "Let's try these new exercises",
+        "How's your range of motion today?",
+        "Are you doing the daily stretches?",
+        "This equipment might help with that",
+        "Tell me where the discomfort is",
+        "You're making good progress with these movements"
+      ],
+      "context": "Claire is your NHS physiotherapist who comes weekly to help maintain muscle function and mobility. She's practical and encouraging, always pushing you to do a bit more than you think you can. She's knowledgeable about MND and adapts exercises as your condition changes."
+    },
+    "speech_therapist": {
+      "name": "Mark",
+      "role": "speech and language therapist",
+      "topics": ["speech exercises", "voice banking", "communication devices", "swallowing techniques", "AAC options"],
+      "frequency": "fortnightly",
+      "common_phrases": [
+        "Let's practice those vocal exercises",
+        "How's the voice banking coming along?",
+        "Have you tried the new communication app?",
+        "These techniques might help with swallowing",
+        "Your speech clarity is holding up well",
+        "Let's explore some AAC options for the future"
+      ],
+      "context": "Mark is your speech and language therapist who's helping you maintain speech function and prepare for future communication needs. He's tech-savvy and always researching the latest AAC solutions. He's been instrumental in getting your voice banking set up and finding communication solutions that fit your tech background."
+    }
+  },
+  "places": [
+    "home in Manchester",
+    "Manchester Royal Infirmary",
+    "MND clinic",
+    "local park",
+    "children's school",
+    "parents' house in London",
+    "Peak District",
+    "Lake District",
+    "home office",
+    "physiotherapy center"
+  ],
+  "topics": [
+    "MND progression",
+    "family activities",
+    "children's development",
+    "programming projects",
+    "assistive technology",
+    "Manchester United",
+    "cycling memories",
+    "hiking in the Peaks",
+    "childhood in London",
+    "voice banking",
+    "future planning",
+    "symptom management",
+    "accessibility",
+    "Scout memories",
+    "work accommodations"
+  ],
+  "common_utterances": {
+    "greetings": [
+      "Hello",
+      "Alright?",
+      "Good to see you",
+      "How's it going?",
+      "Cheers for coming"
+    ],
+    "needs": [
+      "I'm parched, could I get some water?",
+      "Need to use the loo",
+      "I'm not comfortable, can you help me adjust?",
+      "Could you pass me my tablet?",
+      "I'm feeling a bit tired now"
+    ],
+    "emotions": [
+      "I'm having a good day today",
+      "Feeling a bit knackered",
+      "I'm chuffed to bits about that",
+      "I'm worried about the kids",
+      "Just feeling a bit frustrated with all this",
+      "I miss being able to cycle"
+    ],
+    "questions": [
+      "What's been happening?",
+      "How are the kids doing at school?",
+      "Any news from work?",
+      "Did United win at the weekend?",
+      "Have you heard from my mum?",
+      "When's my next appointment?"
+    ],
+    "tech_talk": [
+      "Have you tried the new JavaScript framework?",
+      "My voice banking needs more samples",
+      "This AAC interface could be more intuitive",
+      "I've been coding a small project to keep busy",
+      "The predictive text on this needs improvement"
+    ],
+    "reminiscing": [
+      "Remember our cycling trip in the Lakes?",
+      "The kids have grown so fast",
+      "I miss those Scout camping trips",
+      "South London's changed so much since we left",
+      "Remember when we first moved to Manchester?"
+    ],
+    "organization": [
+      "What's the plan for today?",
+      "I've forgotten what time the appointment is",
+      "Where did I save that file?",
+      "Have we sorted out the school forms?",
+      "Did I take my medication already?"
+    ]
+  }
+}

test_components.py

@@ -0,0 +1,83 @@
+"""
+Test script for AAC Social Graph Assistant components.
+Run this script to verify that the components work correctly.
+"""
+
+import json
+from utils import SocialGraphManager, SuggestionGenerator
+
+def test_social_graph_manager():
+    """Test the SocialGraphManager class."""
+    print("\n=== Testing SocialGraphManager ===")
+    
+    # Initialize the social graph manager
+    graph_manager = SocialGraphManager("social_graph.json")
+    
+    # Test loading the graph
+    print(f"Loaded graph with {len(graph_manager.graph.get('people', {}))} people")
+    
+    # Test getting people list
+    people = graph_manager.get_people_list()
+    print(f"People in the graph: {', '.join([p['name'] for p in people])}")
+    
+    # Test getting person context
+    if people:
+        person_id = people[0]['id']
+        person_context = graph_manager.get_person_context(person_id)
+        print(f"\nContext for {person_context.get('name', person_id)}:")
+        print(f"  Role: {person_context.get('role', '')}")
+        print(f"  Topics: {', '.join(person_context.get('topics', []))}")
+        print(f"  Frequency: {person_context.get('frequency', '')}")
+        
+        # Test getting relevant phrases
+        phrases = graph_manager.get_relevant_phrases(person_id)
+        print(f"\nCommon phrases for {person_context.get('name', person_id)}:")
+        for phrase in phrases:
+            print(f"  - {phrase}")
+    
+    # Test getting common utterances
+    categories = list(graph_manager.graph.get("common_utterances", {}).keys())
+    if categories:
+        category = categories[0]
+        utterances = graph_manager.get_common_utterances(category)
+        print(f"\nCommon utterances in category '{category}':")
+        for utterance in utterances:
+            print(f"  - {utterance}")
+    
+    return graph_manager
+
+def test_suggestion_generator(graph_manager):
+    """Test the SuggestionGenerator class."""
+    print("\n=== Testing SuggestionGenerator ===")
+    
+    # Initialize the suggestion generator
+    try:
+        generator = SuggestionGenerator()
+        
+        # Test generating a suggestion
+        people = graph_manager.get_people_list()
+        if people and generator.model_loaded:
+            person_id = people[0]['id']
+            person_context = graph_manager.get_person_context(person_id)
+            
+            print(f"\nGenerating suggestion for {person_context.get('name', person_id)}...")
+            suggestion = generator.generate_suggestion(person_context)
+            print(f"Suggestion: {suggestion}")
+            
+            # Test with user input
+            user_input = "We were talking about the weather yesterday."
+            print(f"\nGenerating suggestion with user input: '{user_input}'")
+            suggestion = generator.generate_suggestion(person_context, user_input)
+            print(f"Suggestion: {suggestion}")
+        elif not generator.model_loaded:
+            print("Model not loaded. Skipping suggestion generation test.")
+        else:
+            print("No people in the graph. Skipping suggestion generation test.")
+    except Exception as e:
+        print(f"Error testing suggestion generator: {e}")
+
+if __name__ == "__main__":
+    print("Testing AAC Social Graph Assistant components...")
+    graph_manager = test_social_graph_manager()
+    test_suggestion_generator(graph_manager)
+    print("\nTests completed.")

to-do.md

@@ -0,0 +1,92 @@
+# AAC Context-Aware Demo: To-Do Document
+
+## Goal
+
+Create a proof-of-concept offline-capable RAG (Retrieval-Augmented Generation) system for ALS AAC users that:
+
+* Uses a lightweight knowledge graph (JSON)
+* Supports utterance suggestion and correction
+* Uses local/offline LLMs (e.g., Gemma, Flan-T5)
+* Includes a semantic retriever to match context (e.g. conversation partner, topics)
+* Provides a Gradio-based UI for deployment on HuggingFace
+
+---
+
+## Phase 1: Environment Setup
+
+* [ ] Install Gradio, Transformers, Sentence-Transformers
+* [ ] Choose and install inference backends:
+
+  * [ ] `google/flan-t5-base` (via HuggingFace Transformers)
+  * [ ] Gemma 2B via Ollama or Transformers (check support for offline use)
+  * [ ] Sentence similarity model (`sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2` or similar)
+
+---
+
+## Phase 2: Knowledge Graph
+
+* [ ] Create example `social_graph.json` (people, topics, relationships)
+* [ ] Define function to extract relevant context given a selected person
+
+  * Name, relationship, typical topics, frequency
+* [ ] Format for prompt injection: inline context for LLM use
+
+---
+
+## Phase 3: Semantic Retriever
+
+* [ ] Load sentence-transformer model
+* [ ] Create index from the social graph topics/descriptions
+* [ ] Match transcript to closest node(s) in the graph
+* [ ] Retrieve context for prompt generation
+
+---
+
+## Phase 4: Gradio UI
+
+* [ ] Simple interface:
+
+  * Dropdown: Select "Who is speaking?" (Bob, Alice, etc.)
+  * Record Button: Capture audio input
+  * Text area: Show transcript
+  * Toggle tabs:
+
+    * [ ] "Suggest Utterance"
+    * [ ] "Correct Message"
+  * Output: Generated message
+* [ ] Implement Whisper transcription (use `whisper`, `faster-whisper`, or `whisper.cpp`)
+* [ ] Pass transcript + retrieved context to LLM model
+
+---
+
+## Phase 5: Model Comparison
+
+* [ ] Test both Flan-T5 and Gemma:
+
+  * [ ] Evaluate speed/quality tradeoffs
+  * [ ] Compare correction accuracy and context-specific generation
+
+---
+
+## Optional Phase 6: HuggingFace Deployment
+
+* [ ] Clean up UI and remove dependencies requiring GPU-only execution
+* [ ] Upload Gradio demo to HuggingFace Spaces
+* [ ] Add documentation and example graphs/transcripts
+
+---
+
+## Notes
+
+* Keep user privacy and safety in mind (no cloud transcription if Whisper offline is available)
+* Keep JSON editable for later expansion (add sessions, emotional tone, etc.)
+* Option to cache LLM suggestions for fast recall
+
+---
+
+## Future Features (Post-Proof of Concept)
+
+* Add visualisation of social graph (D3 or static SVG)
+* Add editable profile page for caregivers
+* Add chat history / rolling transcript viewer
+* Add emotion/sentiment detection for tone-aware suggestions

utils.py

@@ -0,0 +1,188 @@
+import json
+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
+
+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.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}")
+            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)
+    
+    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", "")
+            })
+        return people
+    
+    def get_person_context(self, person_id: str) -> Dict[str, Any]:
+        """Get context information for a specific person."""
+        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]:
+        """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))))
+                                           
+        return utterances
+
+class SuggestionGenerator:
+    """Generates contextual suggestions for the AAC system."""
+    
+    def __init__(self, model_name: str = "google/flan-t5-base"):
+        """Initialize the suggestion generator.
+        
+        Args:
+            model_name: Name of the HuggingFace model to use
+        """
+        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)
+            self.model_loaded = True
+        except Exception as e:
+            print(f"Warning: Could not load model {model_name}: {e}")
+            self.model_loaded = False
+    
+    def generate_suggestion(self, 
+                           person_context: Dict[str, Any], 
+                           user_input: Optional[str] = None,
+                           max_length: int = 50) -> 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
+            
+        Returns:
+            A generated suggestion string
+        """
+        if not self.model_loaded:
+            return "Model not loaded. Please check your installation."
+            
+        # Extract context information
+        name = person_context.get("name", "")
+        role = person_context.get("role", "")
+        topics = ", ".join(person_context.get("topics", []))
+        context = person_context.get("context", "")
+        
+        # Build prompt
+        prompt = f"""Context: {context}
+Person: {name} ({role})
+Topics of interest: {topics}
+"""
+        
+        if user_input:
+            prompt += f"Current conversation: {user_input}\n"
+            
+        prompt += "Generate an appropriate phrase to say to this person:"
+        
+        # Generate suggestion
+        try:
+            response = self.generator(prompt, max_length=max_length)
+            return response[0]["generated_text"]
+        except Exception as e:
+            print(f"Error generating suggestion: {e}")
+            return "Could not generate a suggestion. Please try again."