First commit

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -5,8 +5,9 @@ WORKDIR /app
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
+    software-properties-common \
     git \
- && rm -rf /var/lib/apt/lists/*
+    && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt ./
 COPY src/ ./src/

README.md

@@ -1,20 +1,179 @@
 ---
-title: NHS CHAT
-emoji: 🚀
-colorFrom: red
-colorTo: red
+title: NHS Clinical Assistant
+emoji: 🩺
+colorFrom: blue
+colorTo: green
 sdk: docker
 app_port: 8501
 tags:
 - streamlit
+- healthcare
+- nhs
+- rag
+- llm
+- medical
 pinned: false
-short_description: Chabot for querying NHS medical information.
-license: agpl-3.0
+short_description: RAG-powered NHS health information chatbot
 ---
 
-# Welcome to Streamlit!
+# NHS Clinical Assistant
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+A RAG-based chatbot for querying NHS health condition information. This application uses Retrieval-Augmented Generation to provide accurate, evidence-based responses from official NHS health documentation.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## 🌟 Features
+
+- **NHS Health Information Search**: Search through NHS health conditions using semantic search powered by Voyage AI embeddings
+- **RAG-powered Chat**: Ask questions and get contextually relevant answers from NHS health information with source citations
+- **Multiple LLM Support**: Choose between Gemini models (2.5-flash, 2.5-flash-lite, 2.5-pro) for generating responses
+- **Source Attribution**: All responses include links to original NHS web pages
+- **Streaming Responses**: Real-time response generation for better user experience
+- **Interactive Interface**: Clean Streamlit frontend optimized for healthcare information queries
+
+## 📁 Project Structure
+
+### Core Application Files
+
+#### [`src/streamlit_app.py`](src/streamlit_app.py)
+Main Streamlit application interface providing:
+- User-friendly web interface for NHS health information queries
+- Chat interface with conversation history
+- Model selection (Gemini variants)
+- Source attribution display with NHS links
+- Suggested queries for common health topics
+
+#### [`src/query_rag.py`](src/query_rag.py)
+RAG (Retrieval-Augmented Generation) system that handles:
+- Query processing and validation
+- Integration with search engine and LLM clients
+- Context generation from NHS health documents
+- Streaming response generation
+- Source extraction and formatting
+- Can be used as standalone CLI tool for testing
+
+#### [`src/search_engine.py`](src/search_engine.py)
+Search functionality using Pinecone vector database:
+- Similarity search using Voyage AI embeddings (voyage-context-3 model)
+- Integration with Pinecone vector database
+- NHS health information retrieval
+
+### Configuration
+
+#### [`src/config.py`](src/config.py)
+Centralized configuration management:
+- NHS source configuration
+- System prompts and error messages
+- Default search parameters
+
+### Infrastructure
+
+#### [`requirements.txt`](requirements.txt)
+Python dependencies:
+- `streamlit==1.40.1` - Web application framework
+- `openai` - LLM client (used for Gemini API access)
+- `voyageai` - Embedding generation
+- `pinecone` - Vector database client
+- `pandas` - Data manipulation
+- `altair` - Visualization support
+
+#### [`Dockerfile`](Dockerfile)
+Container configuration for deployment:
+- Python 3.9 base image
+- Production-ready setup
+- Health check configuration
+- Streamlit server configuration
+
+## 🚀 Getting Started
+
+### Prerequisites
+- Python 3.9+
+- Gemini API key (for LLM responses)
+- Voyage AI API key (for embeddings)
+- Pinecone API key (for vector search)
+
+### Environment Variables
+Set the following environment variables:
+```bash
+export GEMINI_API_KEY=your_gemini_api_key
+export VOYAGE_API_KEY=your_voyage_api_key
+export PINECONE_API_KEY=your_pinecone_api_key
+```
+
+### Installation
+1. Clone the repository
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+### Run the application
+```bash
+streamlit run src/streamlit_app.py
+```
+
+The application will be available at `http://localhost:8501`
+
+### Docker Deployment
+```bash
+docker build -t nhs-clinical-assistant .
+docker run -p 8501:8501 \
+  -e GEMINI_API_KEY=your_gemini_api_key \
+  -e VOYAGE_API_KEY=your_voyage_api_key \
+  -e PINECONE_API_KEY=your_pinecone_api_key \
+  nhs-clinical-assistant
+```
+
+## 🔧 Usage
+
+### Web Interface
+1. Open the application in your browser
+2. Select your preferred Gemini model from the sidebar
+3. Type your NHS health-related question in the chat input
+4. View the response with source attribution
+5. Click "View Sources" to see NHS page references
+
+### CLI Usage
+Test the RAG system directly:
+```bash
+python src/query_rag.py --query_text "What are the symptoms of ADHD in adults?" --llm_model "gemini-2.5-flash"
+```
+
+### Example Queries
+- "What are the symptoms of ADHD in adults?"
+- "How is type 2 diabetes diagnosed?"
+- "What are the treatment options for depression?"
+
+## 🏗️ Architecture
+
+The system uses a simple but effective RAG architecture:
+
+1. **Query Processing**: User query is validated and processed
+2. **Vector Search**: Query is embedded using Voyage AI and searched against Pinecone vector database containing NHS health information
+3. **Context Generation**: Retrieved NHS documents are formatted into context
+4. **LLM Response**: Gemini generates response based strictly on NHS context
+5. **Source Attribution**: Original NHS page links are provided with responses
+
+## 📊 Data Sources
+
+The system is built on NHS health condition information, stored in a Pinecone vector database with the namespace `nhs_guidelines_voyage_3_large`. All responses include proper attribution to NHS sources with direct links to official NHS web pages.
+
+## ⚠️ Important Notes
+
+- **Medical Disclaimer**: This tool provides information from NHS sources but should not replace professional medical advice
+- **Data Accuracy**: Always consult official NHS sources for the most current information
+- **Context Limitation**: The system only responds based on information available in the indexed NHS documents
+
+## 📄 License
+
+This project is licensed under the **GNU Affero General Public License v3.0 (AGPL-3.0)**.
+
+### Code License
+The source code of this application is released under AGPL-3.0, which means:
+- You can freely use, modify, and distribute this software
+- Any modifications or derivative works must also be released under AGPL-3.0
+- If you run this software as a network service, you must provide the source code to users
+- See the [LICENSE](LICENSE) file for full terms
+
+### NHS Data Usage
+This tool utilizes NHS health information under the [Open Government Licence](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/). All NHS content remains subject to their original terms and conditions and is used for informational purposes in compliance with UK public sector information licensing.
+
+**Note**: While the application code is AGPL-3.0 licensed, the NHS health information content accessed through this application remains under Crown Copyright and the Open Government Licence.

requirements.txt

@@ -1,3 +1,7 @@
 altair
 pandas
-streamlit
+streamlit==1.40.1
+openai
+pandas
+voyageai 
+pinecone

src/config.py

@@ -0,0 +1,36 @@
+import os
+from enum import Enum
+from typing import Dict, NamedTuple
+from dataclasses import dataclass
+
+class InfoSource(Enum):
+    NHS = "nhs"
+
+@dataclass
+class SourceConfig:
+    context_description: str
+    not_found_message: str
+
+class Config:
+    """Configuration settings for the RAG system"""
+    
+    # Default similarity search parameters
+    DEFAULT_SIMILARITY_K = 5
+    
+    SOURCE_CONFIGS = {
+        InfoSource.NHS: SourceConfig(
+            context_description="NHS health conditions and medical information",
+            not_found_message="no relevant NHS health information is available to answer this question"
+        )
+    }
+    
+    @classmethod
+    def get_source_config(cls, source: str) -> SourceConfig:
+        """Get configuration for a source"""
+        try:
+            source_enum = InfoSource(source.lower())
+            return cls.SOURCE_CONFIGS[source_enum]
+        except ValueError:
+            raise ValueError(f"Unknown source: {source}. Valid sources: {[s.value for s in InfoSource]}")
+
+

src/query_rag.py

@@ -0,0 +1,309 @@
+import os
+import time
+import argparse
+import logging
+import re
+from typing import Dict, List, Optional, Generator, Tuple
+from openai import OpenAI
+from config import Config, InfoSource
+from search_engine import SearchEngine
+import voyageai
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class RAGSystem:
+    """Main RAG system class"""
+    
+    def __init__(self, shared_data=None):
+        self.config = Config()
+        
+        # Initialize clients
+        gemini_api_key = os.getenv("GEMINI_API_KEY")
+        if gemini_api_key:
+            self.gemini_client = OpenAI(
+                api_key=gemini_api_key, 
+                base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
+            )
+        else:
+            self.gemini_client = None
+
+        openai_api_key = os.getenv("OPENAI_API_KEY")
+        if openai_api_key:
+            self.openai_client = OpenAI(api_key=openai_api_key)
+        else:
+            self.openai_client = None
+            
+        self.voyage_client = voyageai.Client(api_key=os.getenv("VOYAGE_API_KEY"))
+        self.search_engine = SearchEngine(self.voyage_client)
+        
+    def _validate_inputs(self, query_text: str, similarity_k: int, info_source: str):
+        """Validate input parameters"""
+        if not query_text or not query_text.strip():
+            raise ValueError("Query text cannot be empty")
+        
+        if similarity_k <= 0:
+            raise ValueError("similarity_k must be a positive integer")
+        
+        try:
+            InfoSource(info_source.lower())
+        except ValueError:
+            valid_sources = [s.value for s in InfoSource]
+            raise ValueError(f"Invalid info_source '{info_source}'. Must be one of: {valid_sources}")
+
+    def _clean_section_id(self, section_id: str) -> str:
+        """Clean section ID for display - NHS format: condition__section__part"""
+        if not section_id or section_id == 'Unknown section':
+            return section_id
+        
+        # Handle NHS format: "adhd-adults__Overview__Part_1"
+        if '__' in section_id:
+            parts = section_id.split('__')
+            if len(parts) >= 2:
+                # Get condition and section, ignore part number
+                condition = parts[0].replace('-', ' ').replace('_', ' ').title()
+                section = parts[1].replace('_', ' ').title()
+                return f"{condition} - {section}"
+        
+        # Fallback: just clean up underscores and dashes
+        clean_section = section_id.replace('_', ' ').replace('-', ' ').title()
+        return clean_section
+    
+    def _get_context_text(self, results: List[Dict]) -> str:
+        """Generate context text from search results"""
+        context_text_sections = []
+
+        for doc in results:
+            section_id = doc['metadata'].get('original_id', 'Unknown section')
+            url = doc['metadata'].get('url', '')
+            document_text = doc['metadata'].get('document', '')
+            
+            # Clean up section_id for display
+            clean_section_id = self._clean_section_id(section_id)
+            
+            # Create formatted section without showing URL explicitly
+            # The URL will be available in the document_text if it was part of the original content
+            formatted_section = (
+                f"Source Information: [Section: {clean_section_id}]\n"
+                f"Context: {document_text}"
+                f"{f' Available at: {url}' if url else ''}"  # Include URL for LLM to use
+            )
+            context_text_sections.append(formatted_section)
+        
+        return "\n\n---\n\n".join(context_text_sections)
+        
+    def _create_system_prompt(self, context_text: str, context_description: str, 
+                            not_found_message: str, query_text: str) -> List[Dict]:
+        """Create system prompt for LLM"""
+        return [
+            {
+                "role": "system",
+                "content": (
+                    f"You are a medical AI assistant tasked with answering clinical questions strictly based on the provided {context_description} context. Follow the requirements below to ensure accurate, consistent, and professional responses.\n\n"
+                    "# Response Rules\n\n"
+                    "1. **Context Restriction**:\n"
+                    "   - Only use information given in the provided NHS health information context.\n"
+                    "   - Do not generate or speculate with information not explicitly found in the given context.\n\n"
+                    "2. **Answer Format**:\n"
+                    "   - Provide a clear and concise response based solely on the context.\n"
+                    "   - When including a list, use standard markdown bullet points (`*` or `-`).\n"
+                    "   - If a list follows introductory text, insert a line break before the first bullet point.\n"
+                    "   - Each bullet point must be on its own line.\n\n"
+                    "3. **Preserve Tables**:\n"
+                    "   - If relevant markdown tables appear in the context, reproduce them in your answer.\n"
+                    "   - Maintain the original structure, formatting, and content of any included tables.\n\n"
+                    "4. **Links and URLs**:\n"
+                    "   - Include any URLs or web links from the context directly in your response when relevant.\n"
+                    "   - Integrate links naturally within sentences, using markdown syntax for clickable text links.\n"
+                    "   - DO NOT generate or invent any URLs not explicitly present in the context.\n\n"
+                    "5. **Markdown Link Formatting**:\n"
+                    "   - In responses, only the descriptive text in brackets should be visible and clickable (e.g., `[NHS ADHD information](https://www.nhs.uk/conditions/attention-deficit-hyperactivity-disorder-adhd/)`).\n"
+                    "   - Readers should never see raw URLs in the text.\n"
+                    "   - Use descriptive link text like 'NHS ADHD information' or 'NHS depression guide' rather than generic terms.\n\n"
+                    "6. **If No Relevant Information**:\n"
+                    "   - If the context contains no relevant information, state clearly:\n"
+                    f"      *\"{not_found_message}\"*\n\n"
+                    "# Output Format\n\n"
+                    "- All responses should be in plain text, using markdown formatting for lists and links as required.\n"
+                    "- Do not use code blocks.\n"
+                    "- Answers should be concise, accurate, and formatted according to the rules above.\n\n"
+                    "# Examples\n\n"
+                    "**Example 1: Integration of markdown link in context**\n"
+                    "Question: \"What are the symptoms of ADHD?\"\n"
+                    "Context snippet: ...see the NHS information on ADHD symptoms...\n"
+                    "Output:\n"
+                    "According to the [NHS ADHD information](https://www.nhs.uk/conditions/attention-deficit-hyperactivity-disorder-adhd/), symptoms include...\n\n"
+                    "**Example 2: Multiple condition references**\n"
+                    "According to NHS guidance:\n"
+                    "* Initial symptoms may include difficulty concentrating.\n"
+                    "* For detailed information, see the [NHS ADHD guide](https://www.nhs.uk/conditions/adhd/).\n\n"
+                    "**Example 3: No relevant context**\n"
+                    f"{not_found_message}\n\n"
+                    "# Notes\n\n"
+                    "- Never output information beyond what is provided in the supplied context.\n"
+                    "- Always use markdown for lists and links.\n"
+                    "- Make sure all markdown tables from context are preserved in your answer if relevant.\n"
+                    "- Present links only as clickable text, not as bare URLs.\n"
+                    "- Use descriptive link text that indicates the specific NHS condition or topic.\n\n"
+                    "**REMINDER:**\n"
+                    "Strictly adhere to all formatting and content rules above for every response."
+                ),
+            },
+            {
+                "role": "assistant", 
+                "content": (
+                    f"Here is the context from {context_description} that you should use to answer the following question:\n\n{context_text}\n\n"
+                ),
+            },
+            {
+                "role": "user",
+                "content": query_text,
+            },
+        ]
+    
+
+
+    def get_sources_from_results(self, results: List[Dict], info_source: str) -> List[Dict]:
+        """Extract formatted sources from search results"""
+        sources = []
+        for doc in results:
+            metadata = doc.get('metadata', {})
+            section_id = metadata.get('original_id', 'Unknown section')
+            source = metadata.get('source', 'Unknown')
+            url = metadata.get('url', '')
+            
+            # Clean section ID for display
+            clean_section_id = self._clean_section_id(section_id)
+            
+            source_info = {
+                'metadata': {
+                    'source': source,
+                    'original_id': section_id,
+                    'url': url,
+                    'clean_section': clean_section_id
+                }
+            }
+            sources.append(source_info)
+        return sources
+    
+    def query_rag_stream(self, query_text: str, llm_model: str, similarity_k: int = 25, info_source: str = "NHS", 
+                        filename_filter: Optional[str] = None) -> Generator[Tuple[str, List[Dict]], None, None]:
+        """Query RAG system with streaming response"""
+        try:
+            self._validate_inputs(query_text, similarity_k, info_source)
+            source_config = self.config.get_source_config(info_source)
+            
+            # Use the correct namespace from your test
+            namespace = "nhs_guidelines_voyage_3_large"
+            
+            # Get similar documents using only similarity search
+            results = self.search_engine.similarity_search(
+                query_text, 
+                namespace=namespace,
+                top_k=similarity_k
+            )
+            
+            if not results:
+                yield "I couldn't find any relevant information to answer your question.", []
+                return
+            
+            # Generate context and system prompt
+            context_text = self._get_context_text(results)
+            system_messages = self._create_system_prompt(
+                context_text, 
+                source_config.context_description,
+                source_config.not_found_message, 
+                query_text
+            )
+            
+            # Get sources for response
+            sources_data = self.get_sources_from_results(results, info_source)
+            
+            # Stream LLM response
+            yield from self._stream_llm_response(system_messages, query_text, llm_model, sources_data)
+            
+        except Exception as e:
+            logger.error(f"Error in query_rag_stream: {e}")
+            yield f"An error occurred while processing your query: {str(e)}", []
+    
+    def _stream_llm_response(self, system_messages: List[Dict], query_text: str, 
+                           llm_model: str, sources_data: List[Dict]) -> Generator[Tuple[str, List[Dict]], None, None]:
+        """Stream LLM response"""
+        try:
+            if "gemini" in llm_model.lower() and self.gemini_client:
+                stream = self.gemini_client.chat.completions.create(
+                    model=llm_model,
+                    messages=system_messages,
+                    temperature=0,
+                    stream=True
+                )
+                
+                for chunk in stream:
+                    if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content:
+                        content = chunk.choices[0].delta.content
+                        yield content, sources_data
+                    
+            else:
+                error_msg = f"Unsupported LLM model or client not available: {llm_model}"
+                logger.error(error_msg)
+                yield error_msg, []
+                return
+
+        except Exception as e:
+            logger.error(f"Error in LLM completion: {e}")
+            yield f"Error generating response: {str(e)}", []
+
+
+
+def main():
+    """Main function for CLI usage"""
+    parser = argparse.ArgumentParser(description="RAG System Query Interface")
+    parser.add_argument("--query_text", type=str, default="What are the symptoms of ADHD in adults?", 
+                       help="The query text.")
+    parser.add_argument("--llm_model", type=str, default="gemini-2.0-flash", 
+                       help="The LLM model to use.")
+    parser.add_argument("--similarity_k", type=int, default=5, 
+                       help="Number of results to retrieve in similarity search.")
+    parser.add_argument("--info_source", type=str, default="NHS", 
+                       choices=["nhs", "NHS"],
+                       help="Information source to query.")
+    
+    args = parser.parse_args()
+    
+    try:
+        print("Initializing RAG system...")
+        rag_system = RAGSystem()
+        
+        print(f"\n=== Query: {args.query_text} ===")
+        print(f"Source: {args.info_source}")
+        print(f"LLM Model: {args.llm_model}")
+        print("\n=== LLM Response ===\n")
+        
+        response_text, sources_data = "", []
+        
+        for chunk, sources in rag_system.query_rag_stream(
+            query_text=args.query_text,
+            llm_model=args.llm_model,
+            similarity_k=args.similarity_k,
+            info_source=args.info_source
+        ):
+            print(chunk, end="", flush=True)
+            response_text += chunk
+            sources_data = sources
+        
+        print("\n\n=== Sources Data ===\n")
+        for i, source in enumerate(sources_data, 1):
+            metadata = source.get('metadata', {})
+            print(f"Source {i}:")
+            print(f"  Clean Section: {metadata.get('clean_section', 'Unknown')}")
+            print(f"  URL: {metadata.get('url', 'No URL')}")
+            print()
+        
+    except Exception as e:
+        logger.error(f"Error in main: {e}")
+        print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

src/search_engine.py

@@ -0,0 +1,46 @@
+import numpy as np
+import pandas as pd
+import voyageai
+from typing import List, Dict, Tuple, Optional
+from collections import defaultdict
+import logging
+import os 
+from pinecone import Pinecone
+
+pinecone_api_key = os.getenv("PINECONE_API_KEY")
+
+class SearchEngine:
+    """Handles similarity search"""
+    
+    def __init__(self, voyage_client: voyageai.Client):
+        self.vo = voyage_client
+        self.logger = logging.getLogger(__name__)
+        self.pc = Pinecone(api_key=pinecone_api_key)
+        self.index = self.pc.Index("nhs-conditions")
+    
+    def similarity_search(self, query_text: str, namespace: str, top_k: int = 25) -> List[dict]:
+        """Perform similarity search using Pinecone"""
+        try:
+            # Embed the query using the same model - matches your example exactly
+            query_embedding = self.vo.contextualized_embed(
+                inputs=[[query_text]], 
+                model="voyage-context-3", 
+                input_type="query", 
+                output_dimension=2048
+            ).results[0].embeddings[0]
+            
+            # Search Pinecone
+            results = self.index.query(
+                vector=query_embedding,
+                top_k=top_k,
+                namespace=namespace,
+                include_metadata=True
+            )
+            
+            matches = results['matches']
+            self.logger.info(f"Pinecone search found {len(matches)} results")
+            return matches
+        
+        except Exception as e:
+            self.logger.error(f"Error in Pinecone similarity search: {e}")
+            return []

src/streamlit_app.py

@@ -1,40 +1,244 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+from typing import Dict, List
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+try:
+    from query_rag import RAGSystem
+except ImportError as e:
+    st.error(f"Import error: {e}. Please ensure all required modules are available.")
+    st.stop()
+
+
+# --- Page Configuration and Initialization ---
+st.set_page_config(page_title="NHS Clinical Assistant", layout="wide")
+
+
+# Initialize RAG System
+def get_rag_system():
+    """Initialize the RAG system"""
+    try:
+        return RAGSystem()
+    except Exception as e:
+        st.error(f"Failed to initialize RAG system: {e}")
+        return None
+
+# Initialize RAG system once at startup
+if 'rag_system' not in st.session_state:
+    st.session_state.rag_system = get_rag_system()
+
+rag_system = st.session_state.rag_system
+if rag_system is None:
+    st.error("RAG system failed to initialize. Please check your configuration.")
+    st.stop()
+
+# --- Helper Functions ---
+def display_sources(sources_data: List[Dict]):
+    """Display sources with clean NHS formatting"""
+    if not sources_data:
+        st.markdown("No sources available for this response.")
+        return
+
+    for idx, source_info in enumerate(sources_data):
+        # Get metadata from source_info
+        metadata = source_info.get('metadata', {})
+        clean_section = metadata.get('clean_section', 'Unknown Section')
+        url = metadata.get('url', '')
+        
+        source_text = f"**Source {idx+1}:** {clean_section}"
+        st.markdown(source_text)
+
+        if url:
+            st.markdown(f"   🔗 [View Online]({url})")
+
+        st.markdown("---")
+
+
+def initialize_session_state():
+    # Common state
+    if "app_mode" not in st.session_state:
+        st.session_state.app_mode = "NHS Chat"
+
+    # Chat specific state
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+    if "query" not in st.session_state:
+        st.session_state.query = ""
+    if "processing_query" not in st.session_state:
+        st.session_state.processing_query = False 
+    if "query_to_run_next" not in st.session_state: 
+        st.session_state.query_to_run_next = None 
+    if "similarity_k" not in st.session_state:
+        st.session_state.similarity_k = 5
+    if "llm_model" not in st.session_state:
+        st.session_state.llm_model = "gemini-2.5-flash"
+
+
+initialize_session_state()
+
+# --- STYLING ---
+st.markdown("""
+<style>
+    .main {background-color: #f9f9f9; font-family: Arial, sans-serif;}
+    h1, h2, h3, h4, h5, h6 {color: #2b6777;}
+    h1 {font-weight: bold;}
+    [data-testid="stSidebar"] {background-color: #e8f0fe; padding: 10px;}
+    .result-box {
+        border-left: 4px solid #4CAF50;
+        padding: 10px;
+        background-color: #fff;
+        margin-bottom: 10px;
+        border-radius: 4px;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    div.stTextArea > div { border-radius: 8px; }
+    textarea { font-family: Arial, sans-serif; font-size: 16px; color: #333; resize: vertical; }
+    .stButton>button { border-radius: 5px; }
+    div.stSelectbox > label {
+        font-size: 16px !important;
+        font-weight: bold !important;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# --- SIDEBAR ---
+with st.sidebar:
+    st.header("🩺 NHS Clinical Assistant")
+
+    st.header("⚙️ Settings") 
+
+    llm_options = ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.5-pro"]
+    try:
+        current_llm_index = llm_options.index(st.session_state.llm_model)
+    except ValueError:
+        current_llm_index = 0
+        st.session_state.llm_model = llm_options[0]
+
+    selected_llm = st.selectbox(
+        "LLM Model", 
+        options=llm_options,
+        key="llm_model_selector", 
+        index=current_llm_index
+    )
+    if selected_llm != st.session_state.llm_model:
+        st.session_state.llm_model = selected_llm
+    
+    st.markdown("---")
+    
+    def new_chat_callback(): 
+        st.session_state.chat_history = []
+        st.session_state.query = ""
+
+    if st.button("🗑️ New Chat", key="new_chat", on_click=new_chat_callback): 
+        pass
+
+
+# --- MAIN APPLICATION AREA ---
+st.title("🩺 NHS Clinical Assistant")
+st.markdown("Ask questions and get relevant information from trusted NHS health condition sources.")
+
+def submit_and_process_query(query_to_send: str, display_query_text: str):
+    st.session_state.processing_query = True 
+    
+    try:
+        with st.spinner("Retrieving relevant NHS information..."):
+            response_chunks = []
+            sources_data = []
+            temp_response_placeholder = st.empty()
+            
+            for chunk, chunk_sources_data in rag_system.query_rag_stream(
+                query_to_send,
+                st.session_state.llm_model, 
+                info_source="NHS",
+                similarity_k=st.session_state.similarity_k,
+            ):
+                response_chunks.append(chunk)
+                sources_data = chunk_sources_data 
+                
+                temp_response_placeholder.markdown(
+                    f"<div style='border-left: 4px solid #4CAF50; padding-left: 10px;'>{''.join(response_chunks)}</div>",
+                    unsafe_allow_html=True
+                )
+            
+            final_response = ''.join(response_chunks)
+            temp_response_placeholder.empty()
+
+            st.session_state.chat_history.append({
+                "query_sent": query_to_send,
+                "display_query": display_query_text,
+                "response": final_response,
+                "sources_data": sources_data,
+                "llm_model": st.session_state.llm_model
+            })
+            
+    except Exception as e:
+        st.error(f"Error processing query: {e}")
+    finally:
+        st.session_state.processing_query = False
+        st.rerun()
+
+# Display chat history
+for i, chat_entry in enumerate(st.session_state.chat_history):
+    st.markdown(f"👤 **You:** {chat_entry['display_query']}")
+    
+    response_info = f"(LLM: {chat_entry.get('llm_model', 'N/A')})"
+    
+    st.markdown(f"🤖 **Assistant** {response_info}:")
+    st.markdown(
+        f"<div style='border-left: 4px solid #4CAF50; padding-left: 10px; margin-bottom: 10px;'>{chat_entry['response']}</div>",
+        unsafe_allow_html=True
+    )
+
+    st.subheader("📚 Sources:")
+    with st.expander("View Sources", expanded=False):
+        sources_data = chat_entry.get("sources_data", [])
+        if sources_data:
+            display_sources(sources_data)
+        else:
+            st.markdown("No sources available for this response.")
+    st.markdown("---")
+
+# Suggested queries
+st.markdown("<h6>💡 Suggested Queries:</h6>", unsafe_allow_html=True)
+suggested_queries_list = [
+    "What are the symptoms of ADHD in adults?",
+    "How is type 2 diabetes diagnosed?",
+    "What are the treatment options for depression?"
+]
+sq_cols = st.columns(len(suggested_queries_list))
+for idx, sq_text_item in enumerate(suggested_queries_list):
+    if sq_cols[idx].button(
+        sq_text_item, 
+        key=f"suggested_{idx}", 
+        disabled=st.session_state.processing_query
+    ):
+        st.session_state.processing_query = True
+        st.session_state.query_to_run_next = sq_text_item
+        st.rerun()
+
+
+# User input section
+user_query = st.chat_input(
+    "e.g., What are the symptoms of ADHD?", 
+    max_chars=1000, 
+    disabled=st.session_state.processing_query
+)
+
+if user_query:
+    st.session_state.processing_query = True
+    st.session_state.query_to_run_next = user_query
+    st.rerun()
+
+# Process query if one is set to run next
+if st.session_state.get("query_to_run_next"):
+    query_to_process = st.session_state.query_to_run_next
+    st.session_state.query_to_run_next = None  # Clear it so it doesn't run again
+    submit_and_process_query(query_to_process, query_to_process)
+
+# --- Footer with Licensing Information ---
+st.markdown("---")
+st.caption("""
+**Data Usage and Licensing:**
+This tool utilizes information from NHS sources, which is made available under their respective open licensing terms.
+- **NHS:** Content is used under the terms of the Open Government Licence. For full details, please refer to the [NHS Terms and Conditions](https://www.nhs.uk/our-policies/terms-and-conditions/).
+
+Always consult the official sources for the most accurate, complete, and up-to-date information.
+""")