Update README to reflect audio-driven pipeline and multi-backend LLM support

- Add project title, description, and metadata for HF Spaces
- Document features: Whisper ASR, interactive Q&A agent, multi-backend LLM switch, ICD-10 mapping, MCP endpoint
- Provide explicit setup instructions, env var table, and local launch options
- Detail MCP API usage and project structure
- Include contribution and prize qualification notes

README.md

@@ -8,174 +8,97 @@ sdk_version: 5.33.0
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: an MCP Tool for Symptom-to-ICD Diagnosis Mapping.
+short_description: an MCP Tool for Audio‑Driven Symptom-to-ICD Diagnosis Mapping.
 tags:
   - mcp-server-track
+  - @MistralTeam
 ---
-A chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and my local RTX 2060 instead of Cloud APIs
-
-# MedCodeMCP – an MCP Tool for Symptom-to-ICD Diagnosis Mapping
-
-## MVP Scope
-- Accept a patient’s symptom description (free-text input).
-- Output a structured JSON with a list of probable diagnoses, each including:
-  - ICD-10 code
-  - Diagnosis name
-  - Confidence score
-- Handle a subset of common symptoms and return the top 3–5 likely diagnoses.
-
-## How It Works
-
-### Input Interface
-- Gradio-based demo UI for testing:
-  - Single text box for symptoms (e.g., “chest pain and shortness of breath”).
-  - Primary interface is programmatic (MCP client calls the server).
-
-### Processing Logic
-- Leverage an LLM (e.g., OpenAI GPT-4 or Anthropic Claude) to parse symptoms and suggest diagnoses.
-- Prompt example:
-  > “The patient reports: {symptoms}. Provide a JSON list of up to 5 possible diagnoses, each with an ICD-10 code and a confidence score between 0 and 1. Use official ICD-10 names and codes.”
-- Recent experiments with medical foundation models (e.g., Google’s Med-PaLM/MedGEMMA) show they can identify relevant diagnosis codes via prompt-based reasoning ([medium.com](https://medium.com)).
-- Using GPT-4/Claude in the loop ensures rapid development and high-quality suggestions ([publish0x.com](https://publish0x.com)).
-
-### Confidence Scoring
-- Instruct the LLM to assign a subjective probability (0–1) for each diagnosis.
-- Accept approximate confidences for MVP.
-- Alternative: rank by output order (first = highest confidence).
-
-### ICD-10 Code Mapping
-- Trust LLM’s knowledge of common ICD-10 codes (e.g., chest pain → R07.9, heart attack → I21.x).
-- Sanity-check:
-  - Maintain a small dictionary of common ICD-10 codes.
-  - Use regex to verify code format.
-  - Flag or adjust codes that don’t match known patterns.
-- Future improvement: integrate a full ICD-10 lookup list for validation.
-
-### Alternate Approach
-- Use an open model fine-tuned for ICD coding (e.g., Clinical BERT on Hugging Face) to predict top ICD-10 codes from clinical text.
-- Requires more coding and possibly a GPU, but feasible.
-- For hackathon MVP, prioritize API-based approach with GPT/Claude ([huggingface.co](https://huggingface.co)).
-
-### Output Format
-- JSON structure for easy agent parsing. Example:
-  ```json
-  {
-    "diagnoses": [
-      {
-        "icd_code": "I20.0",
-        "diagnosis": "Unstable angina",
-        "confidence": 0.85
-      },
-      {
-        "icd_code": "J18.9",
-        "diagnosis": "Pneumonia, unspecified organism",
-        "confidence": 0.60
-      }
-    ]
-  }
-````
-
-* Input: “chest pain and shortness of breath”
-* Output: Cardiac-related issues (e.g., angina/MI) and respiratory causes, each with confidence estimates.
-* Structured output aligns with MCP tool requirements for downstream agent reasoning.
-
-## Gradio MCP Integration
-
-* Implement logic in `app.py` of a Gradio Space.
-* Tag README with `mcp-server-track` as required by hackathon.
-* Follow “Building an MCP Server with Gradio” guide:
-
-  * Use Gradio SDK 5.x.
-  * Define a tool function with metadata for agent discovery.
-  * Expose a prediction endpoint.
-
-### Example Gradio Definition (simplified)
-
-```python
-import gradio as gr
-import openai
-def symptom_to_diagnosis(symptoms: str) -> dict:
-    prompt = f"""The patient reports: {symptoms}. Provide a JSON list of up to 5 possible diagnoses, each with an ICD-10 code and a confidence score between 0 and 1. Use official ICD-10 names and codes."""
-    response = openai.ChatCompletion.create(
-        model="gpt-4",
-        messages=[{"role": "system", "content": prompt}],
-        temperature=0.2
-    )
-    # Parse response content as JSON
-    return response.choices[0].message.content
-demo = gr.Interface(
-    fn=symptom_to_diagnosis,
-    inputs=gr.Textbox(placeholder="Enter symptoms here..."),
-    outputs=gr.JSON(),
-    title="MedCodeMCP Symptom-to-ICD Mapper",
-)
-demo.launch()
-```
-
-* Ensure MCP metadata is included so an external agent can discover and call `symptom_to_diagnosis`.
-
-## User Demo (Client App)
-
-* Create a separate Gradio Space or local script that:
-
-  * Calls the MCP server endpoint.
-  * Renders JSON result in a user-friendly format.
-* Optionally record a video demonstration:
-
-  * Show an agent (e.g., Claude-2 chatbot) calling the MCP tool.
-  * Verify end-to-end functionality.
-
-## MVP Development Steps
-
-1. **Set Up Gradio Space**
+A voice‑enabled medical assistant that takes patient audio complaints, engages in follow‑up questions, and returns structured ICD‑10 diagnosis suggestions via an MCP endpoint. fileciteturn2file0
 
-   * Initialize a new Hugging Face Space with Gradio SDK 5.x.
-   * Tag README with `mcp-server-track`.
+# Features
 
-2. **Implement Symptom-to-Diagnosis Function**
+- **Audio input & ASR**: Use Whisper to transcribe real‑time patient audio (e.g. “I’ve had a dry cough for three days”).
+- **Interactive Q&A agent**: The LLM asks targeted clarifications (“Is your cough dry or productive?”) until ready to diagnose.
+- **Multi‑backend LLM**: Switch dynamically between OpenAI GPT, Mistral (HF), or any local transformers model via env flags.
+- **ICD‑10 mapping**: Leverage LlamaIndex to vector‑retrieve the most probable ICD‑10 codes with confidence scores.
+- **MCP‑server ready**: Exposes a `/mcp` REST endpoint for seamless integration with agent frameworks.
 
-   * Write a Python function to:
+# Getting Started
 
-     * Accept symptom text.
-     * Call GPT-4/Claude API with JSON-output prompt.
-     * Parse the model’s JSON response into a Python dictionary.
-     * Sanitize and validate JSON output.
-   * Fallback: rule-based approach or offline model for demo cases if API limits are reached.
+## Clone & Install
 
-3. **Testing**
-
-   * Input various symptom combinations.
-   * Verify sensibility of diagnoses and correctness of ICD-10 codes.
-   * Tweak prompt to improve specificity.
-   * Ensure JSON structure is valid.
+```bash
+git clone https://huggingface.co/spaces/gpaasch/Grahams_Gradio_Agents_MCP_Hackathon_2025_Submission.git
+cd Grahams_Gradio_Agents_MCP_Hackathon_2025_Submission
+python3 -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt
+```
 
-4. **Confidence Calibration**
+## Environment Variables
+
+| Name                 | Description                                               | Default           |
+|----------------------|-----------------------------------------------------------|-------------------|
+| `OPENAI_API_KEY`     | OpenAI API key for GPT calls                              | none (required)   |
+| `HUGGINGFACEHUB_API_TOKEN` | HF token for Mistral/inference models                | none (required for Mistral) |
+| `USE_LOCAL_GPU`      | Set to `1` to use a local transformers model (no credits) | `0`               |
+| `LOCAL_MODEL`        | Path or HF ID of local model (e.g. `distilgpt2`)          | `gpt2`            |
+| `USE_MISTRAL`        | Set to `1` to use Mistral via HF instead of OpenAI         | `0`               |
+| `MISTRAL_MODEL`      | HF ID for Mistral model (`mistral-small/medium/large`)    | `mistral-large`   |
+| `MISTRAL_TEMPERATURE`| Sampling temperature for Mistral                          | `0.7`             |
+| `MISTRAL_MAX_INPUT`  | Max tokens for input prompt                               | `4096`            |
+| `MISTRAL_NUM_OUTPUT` | Max tokens to generate                                    | `512`             |
+
+## Launch Locally
+
+```bash
+# Option A: Default (OpenAI)
+python app.py
+
+# Option B: Mistral backend
+export USE_MISTRAL=1
+export HUGGINGFACEHUB_API_TOKEN="hf_..."
+python app.py
+
+# Option C: Local GPU (no credits)
+export USE_LOCAL_GPU=1
+export LOCAL_MODEL="./distilgpt2"
+python app.py
+```
 
-   * Define how confidence scores are assigned:
+Open http://localhost:7860 to:
+1. Record your symptoms via the **Microphone** widget.  
+2. Engage in follow‑up Q&A until the agent returns a JSON diagnosis.  
 
-     * Use LLM’s self-reported confidences, or
-     * Rank by output order.
-   * Document confidence methodology in README.
+## MCP API Usage
 
-5. **Integrate with Gradio Blocks**
+Send a POST to `/mcp` to call the `transcribe_and_respond` tool programmatically:
 
-   * Wrap the function in a Gradio interface (`gr.Interface` or `gr.ChatInterface`).
-   * Expose function as an MCP tool with appropriate metadata.
-   * Test via `gradio.Client` or HTTP requests.
+```bash
+curl -X POST http://localhost:7860/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"tool":"transcribe_and_respond","input":{"audio": "<base64_audio>", "history": []}}'
+```
 
-6. **Build a Quick Client (Optional)**
+The response will be a JSON chat history, ending with your final ICD‑10 suggestions.
 
-   * Option A: Second Gradio Space as MCP client showing how an LLM calls the tool.
-   * Option B: Local script using `requests` to call the deployed Space’s prediction API.
-   * Prepare a screen recording illustrating agent invocation.
+# Project Structure
 
-7. **Polish Documentation**
+```
+├── app.py                      # Root wrapper (HF entrypoint)
+├── src/
+│   └── app.py                  # Core Gradio & agent logic
+├── utils/
+│   └── llama_index_utils.py    # LLM predictor & indexing utils
+├── data/
+│   └── icd10cm_tabular_2025/   # ICD-10 dataset
+├── requirements.txt            # Dependencies
+└── README.md                   # This file
+```
 
-   * In README:
+# Contributing & Support
 
-     * Explain tool functionality and usage.
-     * Include hackathon requirements: track tag, demo video or client link.
-     * List technologies used (e.g., “Uses OpenAI GPT-4 via API to map symptoms to diagnoses”).
-     * Provide example usage and sample inputs/outputs.
+- Open an issue or discussion on the [Hugging Face Space](https://huggingface.co/spaces/gpaasch/Grahams_Gradio_Agents_MCP_Hackathon_2025_Submission/discussions).  
+- Tag `@MistralTeam` to qualify for the \$2,000 Mistral prize.  
+- Post on Discord in the **#hackathon** channel for live help.
 
-*By completing these steps, the MVP will demonstrate end-to-end functionality: input symptoms → structured diagnostic insights with ICD-10 codes and confidence scores via an MCP server.*
+---