checkpoint 2 - we are in a very good position right now, audio transcription is working, gradio page looks good, local llms are working, returning the consultation, the json that will be sent to the mcp client, and a debugging panel

app.py

@@ -1,287 +1,218 @@
 import gradio as gr
 from utils.model_configuration_utils import select_best_model, ensure_model
 from services.llm import build_llm
+from utils.voice_input_utils import update_live_transcription, format_response_for_user
 from services.embeddings import configure_embeddings
-from services.indexing import build_symptom_index
-from utils.voice_input_utils import enhanced_process_speech, format_response_for_user, get_asr_pipeline
+from services.indexing import create_symptom_index
 import torch
+import torchaudio
 import torchaudio.transforms as T
 import json
+import re
 
-# 1) Model selection & download
+# ========== Model setup ==========
 MODEL_NAME, REPO_ID = select_best_model()
 model_path = ensure_model()
-print(f"Using model: {MODEL_NAME} from {REPO_ID}")
-print(f"Model path: {model_path}")
-print(f"Model requirements: {MODEL_NAME} requires at least 4GB VRAM and 8GB RAM.")
+print(f"Using model: {MODEL_NAME} from {REPO_ID}", flush=True)
+print(f"Model path: {model_path}", flush=True)
 
-# 2) LLM and embeddings config
+# ========== LLM initialization ==========
+print("\n<<< before build_llm: ", flush=True)
 llm = build_llm(model_path)
-configure_embeddings()
-print(f"LLM configured with model: {model_path}")
-print("Embeddings configured successfully.")
-
-# 3) Index setup
-symptom_index = build_symptom_index()
-print("Symptom index built successfully.")
-print("Ready for queries.")
+print(">>> after build_llm", flush=True)
 
-# --- System prompt ---
-SYSTEM_PROMPT = """
-You are a medical assistant helping a user narrow down to the most likely ICD-10 code.
-At each turn, EITHER ask one focused clarifying question (e.g. "Is your cough dry or productive?")
-or, if you have enough info, output a final JSON with fields:
-{"diagnoses":[…], "confidences":[…]}.
-"""
-
-# Build enhanced Gradio interface
+# ========== Embeddings & index setup ==========
+print("\n<<< before configure_embeddings: ", flush=True)
+configure_embeddings()
+print(">>> after configure_embeddings", flush=True)
+print("Embeddings configured and ready", flush=True)
+
+print("\n<<< before create_symptom_index: ", flush=True)
+symptom_index = create_symptom_index()
+print(">>> after create_symptom_index", flush=True)
+print("Symptom index built successfully. Ready for queries.", flush=True)
+
+# ========== Prompt template ==========
+SYSTEM_PROMPT = (
+    "You are a medical assistant helping a user narrow down to the most likely ICD-10 code. "
+    "At each turn, either ask one focused clarifying question (e.g. 'Is your cough dry or productive?') "
+    "or if you have enough information, provide a final JSON with fields: {\"diagnoses\": [...], "
+    "\"confidences\": [...], \"follow_up\": [...]}. Output must be valid JSON with no trailing commas. Your output MUST be strictly valid JSON, starting with '{' and ending with '}', with no extra text outside the JSON."
+)
+
+# ========== Generator handler ==========
+def on_submit(symptoms_text, history):
+    log = []
+    print("on_submit called", flush=True)
+
+    # Placeholder
+    msg = "🔍 Received input"
+    log.append(msg)
+    print(msg, flush=True)
+    history = history + [{"role": "assistant", "content": "Processing your request..."}]
+    yield history, None, "\n".join(log)
+
+    # Validate
+    if not symptoms_text.strip():
+        msg = "❌ No symptoms provided"
+        log.append(msg)
+        print(msg, flush=True)
+        result = {"error": "No input provided", "diagnoses": [], "confidences": [], "follow_up": []}
+        yield history, result, "\n".join(log)
+        return
+
+    # Clean input
+    cleaned = symptoms_text.strip()
+    msg = f"🔄 Cleaned text: {cleaned}"
+    log.append(msg)
+    print(msg, flush=True)
+    yield history, None, "\n".join(log)
+
+    # Semantic query
+    msg = "🔍 Running semantic query"
+    log.append(msg)
+    print(msg, flush=True)
+    yield history, None, "\n".join(log)
+
+    qe = symptom_index.as_query_engine(retriever_kwargs={"similarity_top_k": 5})
+    hits = qe.query(cleaned)
+    msg = f"🔍 Retrieved context entries"
+    log.append(msg)
+    print(msg, flush=True)
+    history = history + [{"role": "assistant", "content": msg}]
+    yield history, None, "\n".join(log)
+
+    # Build prompt with minimal context
+    context_list = []
+    for node in getattr(hits, 'source_nodes', [])[:3]:
+        md = getattr(node, 'metadata', {}) or {}
+        context_list.append(f"{md.get('code','')}: {md.get('description','')}")
+    context_text = "\n".join(context_list)
+    prompt = (
+        f"{SYSTEM_PROMPT}\n\n"
+        f"User symptoms: '{cleaned}'\n\n"
+        f"Relevant ICD-10 context:\n{context_text}\n\n"
+        "Respond with valid JSON."
+    )
+    msg = "✏️ Prompt built"
+    log.append(msg)
+    print(msg, flush=True)
+    yield history, None, "\n".join(log)
+
+    # Call LLM
+    # Use constrained decoding to enforce JSON-only output
+    response = llm.complete(prompt, stop=["}"]) # stop after closing brace
+    raw = getattr(response, 'text', str(response))
+    # Truncate extra content after the final JSON object
+    if not raw.strip().endswith('}'):
+        end_idx = raw.rfind('}')
+        if end_idx != -1:
+            raw = raw[:end_idx+1]
+    msg = "📡 Raw LLM response received"
+    log.append(msg)
+    print(msg, flush=True)
+    yield history, None, "\n".join(log)
+
+    # Parse JSON
+    cleaned_raw = re.sub(r",\s*([}\]])", r"\1", raw)
+    try:
+        parsed = json.loads(cleaned_raw)
+        msg = "✅ JSON parsed"
+    except Exception as e:
+        msg = f"❌ JSON parse error: {e}"
+        parsed = {"error": str(e), "raw": raw}
+    log.append(msg)
+    print(msg, flush=True)
+    yield history, parsed, "\n".join(log)
+
+    # Final assistant message
+    assistant_msg = format_response_for_user(parsed)
+    history = history + [{"role": "assistant", "content": assistant_msg}]
+    msg = "✅ Final response appended"
+    log.append(msg)
+    print(msg, flush=True)
+    yield history, parsed, "\n".join(log)
+
+# ========== Gradio UI ==========
 with gr.Blocks(theme="default") as demo:
     gr.Markdown("""
     # 🏥 Medical Symptom to ICD-10 Code Assistant
-    
-    ## About
-    This application is part of the Agents+MCP Hackathon. It helps medical professionals 
-    and patients understand potential diagnoses based on described symptoms.
-    
-    ### How it works:
-    1. Either click the record button and describe your symptoms or type them into the textbox
-    2. The AI will analyze your description and suggest possible diagnoses
-    3. Answer follow-up questions to refine the diagnosis
-    """)
-    
+    ## Describe symptoms by typing or speaking.
+    Debug log updates live below.
+    """
+    )
     with gr.Row():
         with gr.Column(scale=2):
-            # Add text input above microphone
-            with gr.Row():
-                text_input = gr.Textbox(
-                    label="Type your symptoms",
-                    placeholder="Or type your symptoms here...",
-                    lines=3
-                )
-                submit_btn = gr.Button("Submit", variant="primary")
-            
-            # Existing microphone row
-            with gr.Row():
-                microphone = gr.Audio(
-                    sources=["microphone"],
-                    streaming=True,
-                    type="numpy",
-                    label="Describe your symptoms"
-                )
-                transcript_box = gr.Textbox(
-                    label="Transcribed Text",
-                    interactive=False,
-                    show_label=True
-                )
-                clear_btn = gr.Button("Clear Chat", variant="secondary")
-            
+            text_input = gr.Textbox(
+                label="Type your symptoms",
+                placeholder="I'm feeling under the weather...",
+                lines=3
+            )
+            microphone = gr.Audio(
+                sources=["microphone"],
+                streaming=True,
+                type="numpy",
+                label="Or speak your symptoms..."
+            )
+            submit_btn = gr.Button("Submit", variant="primary")
+            clear_btn = gr.Button("Clear Chat", variant="secondary")
             chatbot = gr.Chatbot(
                 label="Medical Consultation",
                 height=500,
-                container=True,
-                type="messages"  # This is now properly supported by our message format
+                type="messages"
             )
-                
+            json_output = gr.JSON(label="Diagnosis JSON")
+            debug_box = gr.Textbox(label="Debug log", lines=10)
         with gr.Column(scale=1):
-            with gr.Accordion("Enter an API Key to give it more power!", open=False):
-                api_key = gr.Textbox(
-                    label="OpenAI API Key (optional)",
-                    type="password",
-                    placeholder="sk-..."
+            with gr.Accordion("API Keys (optional)", open=False):
+                api_key = gr.Textbox(label="OpenAI Key", type="password")
+                model_selector = gr.Dropdown(
+                    choices=["OpenAI","Modal","Anthropic","MistralAI","Nebius","Hyperbolic","SambaNova"],
+                    value="OpenAI",
+                    label="Model Provider"
                 )
-                
-                with gr.Row():
-                    with gr.Column():
-                        modal_key = gr.Textbox(
-                            label="Modal Labs API Key",
-                            type="password",
-                            placeholder="mk-..."
-                        )
-                        anthropic_key = gr.Textbox(
-                            label="Anthropic API Key",
-                            type="password",
-                            placeholder="sk-ant-..."
-                        )
-                        mistral_key = gr.Textbox(
-                            label="MistralAI API Key",
-                            type="password",
-                            placeholder="..."
-                        )
-                        
-                    with gr.Column():
-                        nebius_key = gr.Textbox(
-                            label="Nebius API Key",
-                            type="password",
-                            placeholder="..."
-                        )
-                        hyperbolic_key = gr.Textbox(
-                            label="Hyperbolic Labs API Key",
-                            type="password",
-                            placeholder="hyp-..."
-                        )
-                        sambanova_key = gr.Textbox(
-                            label="SambaNova API Key",
-                            type="password",
-                            placeholder="..."
-                        )
-                
-                with gr.Row():
-                    model_selector = gr.Dropdown(
-                        choices=["OpenAI", "Modal", "Anthropic", "MistralAI", "Nebius", "Hyperbolic", "SambaNova"],
-                        value="OpenAI",
-                        label="Model Provider"
-                    )
-                    temperature = gr.Slider(
-                        minimum=0,
-                        maximum=1,
-                        value=0.7,
-                        label="Temperature"
-                    )
-    # self promotion at bottom of page
-    gr.Markdown("""
-    ---
-    ### 👋 About the Creator
-    
-    Hi! I'm Graham Paasch, an experienced technology professional!
-    
-    🎥 **Check out my YouTube channel** for more tech content:  
-    [Subscribe to my channel](https://www.youtube.com/channel/UCg3oUjrSYcqsL9rGk1g_lPQ)
-    
-    💼 **Looking for a skilled developer?**  
-    I'm currently seeking new opportunities! View my experience and connect on [LinkedIn](https://www.linkedin.com/in/grahampaasch/)
-    
-    ⭐ If you found this tool helpful, please consider:
-    - Subscribing to my YouTube channel
-    - Connecting on LinkedIn
-    - Sharing this tool with others in healthcare tech
-    """)
+                temperature = gr.Slider(minimum=0, maximum=1, value=0.7, label="Temperature")
 
-    # Event handlers
-    clear_btn.click(lambda: None, None, chatbot, queue=False)
-    
-    microphone.stream(
-        fn=enhanced_process_speech,
-        inputs=[microphone, chatbot, api_key, model_selector, temperature],
-        outputs=chatbot,
-        show_progress="hidden",
-        api_name=False,
-        queue=True  # Enable queuing for better stream handling
+    # Bindings
+    submit_btn.click(
+        fn=on_submit,
+        inputs=[text_input, chatbot],
+        outputs=[chatbot, json_output, debug_box],
+        queue=True
+    )
+    clear_btn.click(
+        lambda: (None, {}, ""),
+        None,
+        [chatbot, json_output, debug_box],
+        queue=False
     )
-    
-    def process_audio(audio_array, sample_rate):
-        """Pre-process audio for Whisper."""
-        if audio_array.ndim > 1:
-            audio_array = audio_array.mean(axis=1)
-        
-        # Convert to tensor for resampling
-        audio_tensor = torch.FloatTensor(audio_array)
-        
-        # Resample to 16kHz if needed
-        if sample_rate != 16000:
-            resampler = T.Resample(sample_rate, 16000)
-            audio_tensor = resampler(audio_tensor)
-            
-        # Normalize
-        audio_tensor = audio_tensor / torch.max(torch.abs(audio_tensor))
-        
-        # Convert back to numpy array and return in correct format
-        return {
-            "raw": audio_tensor.numpy(),  # Key must be "raw"
-            "sampling_rate": 16000        # Key must be "sampling_rate"
-        }
-
-    # Update transcription handler
-    def update_live_transcription(audio):
-        """Real-time transcription updates."""
-        if not audio or not isinstance(audio, tuple):
-            return ""
-        
-        try:
-            sample_rate, audio_array = audio
-            features = process_audio(audio_array, sample_rate)
-            
-            asr = get_asr_pipeline()
-            result = asr(features)
-            
-            return result.get("text", "").strip() if isinstance(result, dict) else str(result).strip()
-        except Exception as e:
-            print(f"Transcription error: {str(e)}")
-            return ""
-
     microphone.stream(
         fn=update_live_transcription,
         inputs=[microphone],
-        outputs=transcript_box,
-        show_progress="hidden",
+        outputs=[text_input],
+        show_progress=False,
         queue=True
     )
-    
-    clear_btn.click(
-        fn=lambda: (None, "", ""),
-        outputs=[chatbot, transcript_box, text_input],
-        queue=False
-    )
-    
-    def cleanup_memory():
-        """Release unused memory (placeholder for future memory management)."""
-        import gc
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-
-    def process_text_input(text, history):
-        """Process text input with memory management."""
-
-        print("process_text_input received:", text)
 
-        if not text:
-            return history, ""  # Return tuple to clear input
+    # --- About the Creator ---
+    gr.Markdown("""
+    ---
+    ### 👋 About the Creator
 
-        # Process the symptoms using the configured LLM
-        prompt = f"""Given these symptoms: '{text}'
-        Please provide:
-        1. Most likely ICD-10 codes
-        2. Confidence levels for each diagnosis
-        3. Key follow-up questions
+    Hi! I'm Graham Paasch, an experienced technology professional!
 
-        Format as JSON with diagnoses, confidences, and follow_up fields."""
-        
-        response = llm.complete(prompt)
-        
-        try:
-            # Try to parse as JSON first
-            result = json.loads(response.text)
-        except json.JSONDecodeError:
-            # If not JSON, wrap in our format
-            result = {
-                "diagnoses": [],
-                "confidences": [],
-                "follow_up": str(response.text)[:1000]  # Limit response length
-            }
+    🎥 **Check out my YouTube channel** for more tech content:  
+    [Subscribe to my channel](https://www.youtube.com/channel/UCg3oUjrSYcqsL9rGk1g_lPQ)
 
-        new_history = history + [
-            {"role": "user", "content": text},
-            {"role": "assistant", "content": format_response_for_user(result)}
-        ]
-        return new_history, ""  # Return empty string to clear input
+    💼 **Looking for a skilled developer?**
+    I'm currently seeking new opportunities! View my experience and connect on [LinkedIn](https://www.linkedin.com/in/grahampaasch/)
 
-    # Update the submit button handler
-    submit_btn.click(
-        fn=process_text_input,
-        inputs=[text_input, chatbot],
-        outputs=[chatbot, text_input],
-        queue=True
-    ).success(  # Changed from .then to .success for better error handling
-        fn=cleanup_memory,
-        inputs=None,
-        outputs=None,
-        queue=False
+    ⭐ If you found this tool helpful, please consider:
+    - Subscribing to my YouTube channel
+    - Connecting on LinkedIn
+    - Sharing this tool with others in healthcare tech
+    """
     )
 
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,  # Enable sharing via Gradio's temporary URLs
-        show_api=True  # Shows the API documentation
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=True, show_api=True)

services/embeddings.py

@@ -3,4 +3,5 @@ from llama_index.embeddings.huggingface import HuggingFaceEmbedding
 
 
 def configure_embeddings(model_name="sentence-transformers/all-MiniLM-L6-v2"):
+    print("configure_embeddings: using ", model_name)
     Settings.embed_model = HuggingFaceEmbedding(model_name=model_name)

services/indexing.py

@@ -1,4 +1,20 @@
-from src.parse_tabular import create_symptom_index
+from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
+from llama_index.core import Settings
 
-def build_symptom_index():
-    return create_symptom_index()
+def create_symptom_index():
+    """Create and return symptom index from ICD-10 data."""
+    print("build_symptom_index: Loading documents from data directory...")
+    documents = SimpleDirectoryReader(
+        input_dir="data",
+        filename_as_id=True
+    ).load_data()
+    
+    print(f"build_symptom_index: Creating vector index from {len(documents)} documents...")
+    symptom_index = VectorStoreIndex.from_documents(
+        documents,
+        show_progress=True
+    )
+    
+    print("build_symptom_index: Symptom index created successfully")
+
+    return symptom_index

services/llm.py

@@ -2,6 +2,7 @@ from llama_index.core import Settings
 from llama_index.llms.llama_cpp import LlamaCPP
 
 def build_llm(model_path, temperature=0.7, max_tokens=256, context_window=2048):
+    print("build_llm: loading model from", model_path)
     llm = LlamaCPP(
         model_path=model_path,
         temperature=temperature,

src/parse_tabular.py

@@ -2,8 +2,7 @@ import xml.etree.ElementTree as ET
 import json
 import sys
 import os
-from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
-from llama_index.core import Settings
+from ..services.indexing import create_symptom_index
 import logging
 
 logging.basicConfig(level=logging.INFO)
@@ -56,28 +55,6 @@ def main(xml_path=DEFAULT_XML_PATH):
 
     print(f"Wrote {len(icd_to_description)} code entries to {out_path}")
 
-def create_symptom_index():
-    """Create and return symptom index from ICD-10 data."""
-    try:
-        logger.info("Loading documents from data directory...")
-        documents = SimpleDirectoryReader(
-            input_dir="data",
-            filename_as_id=True
-        ).load_data()
-        
-        logger.info(f"Creating vector index from {len(documents)} documents...")
-        index = VectorStoreIndex.from_documents(
-            documents,
-            show_progress=True
-        )
-        
-        logger.info("Symptom index created successfully")
-        return index
-    
-    except Exception as e:
-        logger.error(f"Failed to create symptom index: {str(e)}")
-        raise
-
 # Move this outside the main() function
 symptom_index = None
 

utils/voice_input_utils.py

@@ -10,6 +10,53 @@ feature_extractor = WhisperFeatureExtractor.from_pretrained("openai/whisper-base
 tokenizer = WhisperTokenizer.from_pretrained("openai/whisper-base.en")
 processor = WhisperProcessor(feature_extractor, tokenizer)
 
+# Update transcription handler
+def update_live_transcription(audio):
+    """Real-time transcription updates."""
+
+    print("update_live_transcription called with:", type(audio))
+    
+    if not audio or not isinstance(audio, tuple):
+        return ""
+    
+    try:
+        sample_rate, audio_array = audio
+
+        print(f"got audio tuple – sample_rate={sample_rate}, shape={audio_array.shape}")
+        
+        def process_audio(audio_array, sample_rate):
+            """Pre-process audio for Whisper."""
+            if audio_array.ndim > 1:
+                audio_array = audio_array.mean(axis=1)
+
+            # Convert to tensor for resampling
+            audio_tensor = torch.FloatTensor(audio_array)
+
+            # Resample to 16kHz if needed
+            if sample_rate != 16000:
+                resampler = T.Resample(sample_rate, 16000)
+                audio_tensor = resampler(audio_tensor)
+
+            # Normalize
+            audio_tensor = audio_tensor / torch.max(torch.abs(audio_tensor))
+
+            # Convert back to numpy array and return in correct format
+            return {
+                "raw": audio_tensor.numpy(),  # Key must be "raw"
+                "sampling_rate": 16000        # Key must be "sampling_rate"
+            }
+
+        features = process_audio(audio_array, sample_rate)
+        
+        asr = get_asr_pipeline()
+        result = asr(features)
+
+        return result.get("text", "").strip() if isinstance(result, dict) else str(result).strip()
+
+    except Exception as e:
+        print(f"Transcription error: {str(e)}")
+        return ""
+
 def get_asr_pipeline():
     """Lazy load ASR pipeline with proper configuration."""
     global transcriber
@@ -24,28 +71,6 @@ def get_asr_pipeline():
         )
     return transcriber
 
-def process_audio(audio_array, sample_rate):
-    """Pre-process audio for Whisper."""
-    if audio_array.ndim > 1:
-        audio_array = audio_array.mean(axis=1)
-    
-    # Convert to tensor for resampling
-    audio_tensor = torch.FloatTensor(audio_array)
-    
-    # Resample to 16kHz if needed
-    if sample_rate != 16000:
-        resampler = T.Resample(sample_rate, 16000)
-        audio_tensor = resampler(audio_tensor)
-    
-    # Normalize
-    audio_tensor = audio_tensor / torch.max(torch.abs(audio_tensor))
-    
-    # Convert back to numpy array and return in correct format
-    return {
-        "raw": audio_tensor.numpy(),  # Key must be "raw"
-        "sampling_rate": 16000        # Key must be "sampling_rate"
-    }
-
 def process_speech(audio_data, symptom_index):
     """Process speech input and convert to text."""
     if not audio_data: