push all

Dockerfile

@@ -0,0 +1,55 @@
+# Use a lightweight Python base
+FROM python:3.10-slim
+
+# Prevent interactive prompts & speed up Python
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    TOKENIZERS_PARALLELISM=false
+
+# Set work directory
+WORKDIR /code
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    git \
+    curl \
+    libopenblas-dev \
+    libomp-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (for Docker caching)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Hugging Face tools
+RUN pip install --no-cache-dir huggingface-hub accelerate
+
+# Set Hugging Face cache inside container (persistent, not /tmp)
+ENV HF_HOME=/models/huggingface
+ENV TRANSFORMERS_CACHE=/models/huggingface
+ENV HUGGINGFACE_HUB_CACHE=/models/huggingface
+ENV HF_HUB_CACHE=/models/huggingface
+
+# Create cache dir
+RUN mkdir -p /models/huggingface
+
+# Pre-download model at build time (BioMistral-7B model)
+RUN python -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='BioMistral/BioMistral-7B')"
+
+# Preload tokenizer (avoid runtime delays)
+RUN python -c "from transformers import AutoTokenizer; AutoTokenizer.from_pretrained('BioMistral/BioMistral-7B', use_fast=True)"
+
+# Copy project files
+COPY . .
+
+# Expose FastAPI port (Hugging Face Spaces uses 7860)
+EXPOSE 7860
+
+# Run FastAPI app with uvicorn (single worker)
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

README.md

@@ -1,10 +1,124 @@
----
-title: QuickCare Text
-emoji: 🚀
-colorFrom: green
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# QuickCare Text - MediScope AI
+
+A FastAPI service for medical chat using BioMistral-7B model with **conversational AI support** and **session management**.
+
+## 🚀 Quick Start
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Run the Server
+
+```bash
+uvicorn app:app --host 0.0.0.0 --port 8000 --reload
+```
+
+The server will start on `http://127.0.0.1:8000`
+
+**Note:** On first run, the BioMistral-7B model (~14GB) will be downloaded from Hugging Face. This may take several minutes.
+
+### 3. Test the API
+
+#### Start a new conversation:
+```bash
+curl -X POST "http://127.0.0.1:8000/chat" \
+     -H "Content-Type: application/json" \
+     -d '{"prompt": "I have a rash on my arm that itches for 3 days"}'
+```
+
+**Response:**
+```json
+{
+  "response": "It sounds like you may have a mild skin irritation...",
+  "session_id": "550e8400-e29b-41d4-a716-446655440000"
+}
+```
+
+#### Continue the conversation (use the session_id from previous response):
+```bash
+curl -X POST "http://127.0.0.1:8000/chat" \
+     -H "Content-Type: application/json" \
+     -d '{
+       "prompt": "What should I do about it?",
+       "session_id": "550e8400-e29b-41d4-a716-446655440000"
+     }'
+```
+
+#### Clear a session:
+```bash
+curl -X DELETE "http://127.0.0.1:8000/chat/550e8400-e29b-41d4-a716-446655440000"
+```
+
+## 📁 Project Structure
+
+```
+.
+├── app.py                    # FastAPI application with session management
+├── model/
+│   ├── __init__.py
+│   └── biomistral_service.py # BioMistral model with conversation history
+├── requirements.txt          # Python dependencies
+└── README.md                 # This file
+```
+
+## 🔧 API Endpoints
+
+### `GET /`
+Health check and API information.
+
+### `GET /health`
+Health check endpoint.
+
+### `POST /chat`
+Chat endpoint with conversation support.
+
+**Request Body:**
+```json
+{
+  "prompt": "Your medical question or symptom description",
+  "session_id": "optional-session-id"  // If omitted, a new session is created
+}
+```
+
+**Response:**
+```json
+{
+  "response": "AI-generated medical advice/explanation",
+  "session_id": "session-id-for-continuing-conversation"
+}
+```
+
+### `DELETE /chat/{session_id}`
+Clear conversation history for a specific session.
+
+## 💬 Conversation Features
+
+- **Session Management**: Each conversation has a unique `session_id`
+- **Multi-turn Conversations**: Maintain context across multiple messages
+- **Automatic Session Creation**: New sessions are created automatically if `session_id` is not provided
+- **Conversation History**: Full conversation history is maintained per session
+
+## 🧠 Model Information
+
+- **Model:** BioMistral/BioMistral-7B
+- **Source:** Hugging Face
+- **Purpose:** Medical chat, reasoning, and education
+- **Capabilities:** Multi-turn medical conversations, symptom analysis, medical education
+
+## ⚠️ Important Notes
+
+- This is an **educational tool** and should not replace professional medical consultation
+- Always encourage users to consult healthcare professionals for serious conditions
+- The model is loaded into memory on startup, which may take time and require significant RAM/VRAM
+- Sessions are stored in memory (not persisted). Restarting the server will clear all sessions
+- For production use, consider implementing persistent storage, caching, rate limiting, and proper error handling
+
+## 🔜 Next Steps
+
+- Add `/analyze-image` endpoint (BiomedCLIP)
+- Add `/analyze-text` endpoint (ClinicalBERT)
+- Fuse all endpoints into `/triage` endpoint
+- Add persistent session storage (Redis/Database)

app.py

@@ -0,0 +1,69 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+from model.biomistral_service import chat_with_biomistral, clear_session
+
+app = FastAPI(
+    title="Quickcare",
+    description="AI medical education and symptom assistant with conversation support",
+    version="1.0.0"
+)
+
+class ChatRequest(BaseModel):
+    prompt: str
+    session_id: Optional[str] = None
+
+class ChatResponse(BaseModel):
+    response: str
+    session_id: str
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    """
+    Chat endpoint that maintains conversation context using session_id.
+    
+    If session_id is not provided, a new session will be created.
+    The same session_id can be used to continue a conversation.
+    """
+    try:
+        user_prompt = request.prompt.strip()
+        if not user_prompt:
+            raise HTTPException(status_code=400, detail="Prompt cannot be empty")
+        
+        response, session_id = chat_with_biomistral(
+            user_prompt=user_prompt,
+            session_id=request.session_id
+        )
+        
+        return ChatResponse(response=response, session_id=session_id)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete("/chat/{session_id}")
+async def clear_chat_session(session_id: str):
+    """Clear conversation history for a specific session."""
+    try:
+        cleared = clear_session(session_id)
+        if cleared:
+            return {"message": f"Session {session_id} cleared successfully"}
+        else:
+            raise HTTPException(status_code=404, detail="Session not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/")
+def home():
+    return {
+        "message": "BioMistral AI Chat API is running 🚀",
+        "features": [
+            "Conversational AI with session management",
+            "Multi-turn medical conversations",
+            "Session-based conversation history"
+        ]
+    }
+
+@app.get("/health")
+def health():
+    """Health check endpoint."""
+    return {"status": "healthy"}
+

model/biomistral_service.py

@@ -0,0 +1,96 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+from typing import Dict, List, Tuple
+import uuid
+
+MODEL_NAME = "BioMistral/BioMistral-7B"
+
+print("🔹 Loading BioMistral model... This may take a while on first run.")
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME,
+    device_map="auto",
+    torch_dtype="auto"
+)
+
+chat_pipeline = pipeline(
+    "text-generation",
+    model=model,
+    tokenizer=tokenizer,
+    max_new_tokens=512,
+    temperature=0.7,
+    top_p=0.9
+)
+
+# Store conversation history per session
+conversation_sessions: Dict[str, List[Dict[str, str]]] = {}
+
+SYSTEM_PROMPT = (
+    "You are MediScope AI, a medical assistant that helps patients understand "
+    "their symptoms in simple, safe, and educational language. "
+    "Always encourage professional consultation for serious conditions."
+)
+
+def get_or_create_session(session_id: str) -> List[Dict[str, str]]:
+    """Get existing session or create a new one."""
+    if session_id not in conversation_sessions:
+        conversation_sessions[session_id] = []
+    return conversation_sessions[session_id]
+
+def build_conversation_prompt(history: List[Dict[str, str]], user_prompt: str) -> str:
+    """Build the full conversation prompt from history and new user message."""
+    prompt_parts = [SYSTEM_PROMPT]
+    
+    # Add conversation history
+    for msg in history:
+        if msg["role"] == "user":
+            prompt_parts.append(f"User: {msg['content']}")
+        elif msg["role"] == "assistant":
+            prompt_parts.append(f"Assistant: {msg['content']}")
+    
+    # Add current user message
+    prompt_parts.append(f"User: {user_prompt}")
+    prompt_parts.append("Assistant:")
+    
+    return "\n\n".join(prompt_parts)
+
+def chat_with_biomistral(user_prompt: str, session_id: str = None) -> Tuple[str, str]:
+    """
+    Chat with BioMistral model, maintaining conversation history.
+    
+    Args:
+        user_prompt: The user's message
+        session_id: Optional session ID. If None, a new session is created.
+    
+    Returns:
+        tuple: (response_text, session_id)
+    """
+    # Generate or use provided session ID
+    if session_id is None:
+        session_id = str(uuid.uuid4())
+    
+    # Get conversation history for this session
+    history = get_or_create_session(session_id)
+    
+    # Build the full conversation prompt
+    full_prompt = build_conversation_prompt(history, user_prompt)
+    
+    # Generate response
+    response = chat_pipeline(full_prompt)[0]["generated_text"]
+    
+    # Extract only the assistant's reply (everything after the last "Assistant:")
+    reply = response.split("Assistant:")[-1].strip()
+    
+    # Update conversation history
+    history.append({"role": "user", "content": user_prompt})
+    history.append({"role": "assistant", "content": reply})
+    
+    return reply, session_id
+
+def clear_session(session_id: str) -> bool:
+    """Clear conversation history for a session."""
+    if session_id in conversation_sessions:
+        conversation_sessions[session_id] = []
+        return True
+    return False
+

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn[standard]
+transformers
+torch
+accelerate
+bitsandbytes
+