Pushing the repo

.gitignore

@@ -0,0 +1,8 @@
+# compiled python
+*.pyc
+# PDF
+*.pdf
+# Pickled files
+*.pkl
+
+*.json

.streamlit/config.toml

@@ -0,0 +1,2 @@
+[server]
+headless = true

app.py

@@ -0,0 +1,149 @@
+import streamlit as st
+import os
+import random
+import importlib.util
+import firebase_admin
+from firebase_admin import credentials, firestore
+
+
+# Initialize Firebase
+if not firebase_admin._apps:
+    cred = credentials.Certificate("coco-evaluation-firebase-adminsdk-p3m64-99c4ea22c1.json")
+    firebase_admin.initialize_app(cred)
+db = firestore.client()
+
+
+# Set page configuration as the first command
+st.set_page_config(
+    page_title="TB Chatbot Evaluation",
+    page_icon="👋",
+)
+
+
+# tesing again 
+
+
+# Set passcode for authentication
+PASSCODE = os.environ["MY_PASSCODE"]
+
+# Initialize authentication state
+if "authenticated" not in st.session_state:
+    st.session_state["authenticated"] = False
+
+
+# Initialize session state variables
+def init_session_state():
+    if "authenticated" not in st.session_state:
+        st.session_state["authenticated"] = False
+    if "evaluator_confirmed" not in st.session_state:
+        st.session_state["evaluator_confirmed"] = None
+    if "model_order" not in st.session_state:
+        st.session_state["model_order"] = []
+    if "current_index" not in st.session_state:
+        st.session_state["current_index"] = 0
+    if "models_completed" not in st.session_state:
+        st.session_state["models_completed"] = False
+    if "evaluation_status" not in st.session_state or not st.session_state["evaluation_status"]:
+        st.session_state["evaluation_status"] = {}
+    if "all_evaluations" not in st.session_state:
+        st.session_state["all_evaluations"] = {}
+    if "evaluation_ids" not in st.session_state:
+        st.session_state["evaluation_ids"] = {}
+    if "start_time" not in st.session_state:
+        st.session_state["start_time"] = None
+    if "evaluation_durations" not in st.session_state:
+        st.session_state["evaluation_durations"] = {}
+    if "submitted_evaluations" not in st.session_state:
+        st.session_state["submitted_evaluations"] = set()
+
+
+init_session_state()
+
+
+# Display Welcome Page
+if not st.session_state["authenticated"]:
+    st.markdown(f"<h1 style='text-align: center;'>Welcome to the TB Chatbot Evaluation</h1>", unsafe_allow_html=True)
+    
+    col1, col2, col3 = st.columns([2, 1, 1])
+    with col1:
+        st.write("Are you an evaluator?")
+    with col2:
+        if st.button("Yes"):
+            st.session_state["evaluator_confirmed"] = True
+    with col3:
+        if st.button("No"):
+            st.session_state["evaluator_confirmed"] = False
+
+    if st.session_state["evaluator_confirmed"]:
+        evaluator_id = st.text_input("Enter your Evaluator ID (can be anything)")
+        passcode = st.text_input("Enter Passcode to Access Models (password is the same)", type="password")
+        if st.button("Submit"):
+            print("Hello")
+            if passcode == PASSCODE and evaluator_id:
+                print("Submitted")
+                # Save Evaluator ID
+                db.collection("evaluator_ids").document(evaluator_id).set({
+                    "evaluator_id": evaluator_id,
+                    "timestamp": firestore.SERVER_TIMESTAMP
+                })
+
+                # Update session state
+                st.session_state["authenticated"] = True
+                st.session_state["evaluator_id"] = evaluator_id
+
+
+# Show the main content only if authenticated
+if st.session_state["authenticated"]:
+    # Sidebar with only randomized page navigation
+    with st.sidebar:
+        # Only create the page mapping if it doesn't already exist in the session state
+        if "page_mapping" not in st.session_state:
+            # Get list of page files and randomize their order
+            PAGES_DIR = "pages"
+            page_files = [f for f in os.listdir(PAGES_DIR) if f.endswith(".py")]
+            random.shuffle(page_files)
+            
+            # Create generic names for display
+            generic_names = [f"Model {chr(65 + i)}" for i in range(len(page_files))]
+            
+            # Create a dictionary to map display names to file paths
+            st.session_state["page_mapping"] = {
+                generic_name: os.path.join(PAGES_DIR, page_file) for generic_name, page_file in zip(generic_names, page_files)
+            }
+        
+        # Retrieve the consistent mapping from session state
+        pages = st.session_state["page_mapping"]
+        
+        # Sidebar navigation selectbox with generic labels
+        selected_generic_name = st.selectbox("Navigation", list(pages.keys()), label_visibility="collapsed")
+
+    # Load and run the selected page dynamically using the selected generic name
+    selected_page_path = pages[selected_generic_name]
+    spec = importlib.util.spec_from_file_location(selected_generic_name, selected_page_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    # Display main welcome message
+    st.markdown("""
+        # Welcome to the TB Chatbot Simulation Portal  
+
+        This portal allows you to interact with our TB-powered chatbot, built using OpenAI's GPT-4. Here, you can evaluate multiple chatbot configurations, each designed to foster trust, empathy, and medical accuracy in responses.  
+
+        ## Purpose  
+
+        Your task is to assess the chatbot models by interacting with them using patient scenario-based questions. Evaluate each model based on the following principles:  
+
+        ### Trust  
+        - Does the response convey confidence and reliability?  
+        - Are the answers factually accurate and rooted in medical expertise?  
+                
+        ### Medical Accuracy  
+        - Are responses aligned with current medical guidelines and best practices?  
+        - Do they avoid misinformation or potentially harmful suggestions?  
+
+        ### Empathy  
+        - Does the chatbot demonstrate understanding and compassion?  
+        - Are responses emotionally sensitive and supportive?  
+
+        Your feedback will help us identify the best model to support our mission of enhancing patient communication and care through AI-driven solutions.  
+        """)

environment/environment.yml

@@ -0,0 +1,166 @@
+name: streamlit-env
+channels:
+  - defaults
+dependencies:
+  - ca-certificates=2024.9.24
+  - libcxx=14.0.6
+  - libffi=3.4.4
+  - ncurses=6.4
+  - openssl=3.0.15
+  - pip=24.2
+  - python=3.9.20
+  - readline=8.2
+  - setuptools=75.1.0
+  - sqlite=3.45.3
+  - tk=8.6.14
+  - wheel=0.44.0
+  - xz=5.4.6
+  - zlib=1.2.13
+  - pip:
+      - aiohappyeyeballs==2.4.3
+      - aiohttp==3.10.10
+      - aiosignal==1.3.1
+      - altair==5.4.1
+      - annotated-types==0.7.0
+      - anyio==4.6.2.post1
+      - asgiref==3.8.1
+      - async-timeout==4.0.3
+      - attrs==24.2.0
+      - backoff==2.2.1
+      - bcrypt==4.2.0
+      - blinker==1.8.2
+      - build==1.2.2.post1
+      - cachetools==5.5.0
+      - certifi==2024.8.30
+      - charset-normalizer==3.4.0
+      - chroma-hnswlib==0.7.6
+      - chromadb==0.5.15
+      - click==8.1.7
+      - coloredlogs==15.0.1
+      - dataclasses-json==0.6.7
+      - deprecated==1.2.14
+      - distro==1.9.0
+      - durationpy==0.9
+      - exceptiongroup==1.2.2
+      - fastapi==0.115.3
+      - filelock==3.16.1
+      - flatbuffers==24.3.25
+      - frozenlist==1.5.0
+      - fsspec==2024.10.0
+      - gitdb==4.0.11
+      - gitpython==3.1.43
+      - google-auth==2.35.0
+      - googleapis-common-protos==1.65.0
+      - grpcio==1.67.0
+      - h11==0.14.0
+      - httpcore==1.0.6
+      - httptools==0.6.4
+      - httpx==0.27.2
+      - huggingface-hub==0.26.1
+      - humanfriendly==10.0
+      - idna==3.10
+      - importlib-metadata==8.4.0
+      - importlib-resources==6.4.5
+      - jinja2==3.1.4
+      - jiter==0.6.1
+      - joblib==1.4.2
+      - jsonpatch==1.33
+      - jsonpointer==3.0.0
+      - jsonschema==4.23.0
+      - jsonschema-specifications==2024.10.1
+      - kubernetes==31.0.0
+      - langchain==0.3.4
+      - langchain-community==0.3.3
+      - langchain-core==0.3.13
+      - langchain-huggingface==0.1.0
+      - langchain-text-splitters==0.3.0
+      - langsmith==0.1.137
+      - markdown-it-py==3.0.0
+      - markupsafe==3.0.2
+      - marshmallow==3.23.0
+      - mdurl==0.1.2
+      - mmh3==5.0.1
+      - monotonic==1.6
+      - mpmath==1.3.0
+      - multidict==6.1.0
+      - mypy-extensions==1.0.0
+      - narwhals==1.10.0
+      - networkx==3.2.1
+      - numpy==1.26.4
+      - oauthlib==3.2.2
+      - onnxruntime==1.19.2
+      - openai==1.52.2
+      - opentelemetry-api==1.27.0
+      - opentelemetry-exporter-otlp-proto-common==1.27.0
+      - opentelemetry-exporter-otlp-proto-grpc==1.27.0
+      - opentelemetry-instrumentation==0.48b0
+      - opentelemetry-instrumentation-asgi==0.48b0
+      - opentelemetry-instrumentation-fastapi==0.48b0
+      - opentelemetry-proto==1.27.0
+      - opentelemetry-sdk==1.27.0
+      - opentelemetry-semantic-conventions==0.48b0
+      - opentelemetry-util-http==0.48b0
+      - orjson==3.10.10
+      - overrides==7.7.0
+      - packaging==24.1
+      - pandas==2.2.3
+      - pillow==10.4.0
+      - posthog==3.7.0
+      - propcache==0.2.0
+      - protobuf==4.25.5
+      - pyarrow==17.0.0
+      - pyasn1==0.6.1
+      - pyasn1-modules==0.4.1
+      - pydantic==2.9.2
+      - pydantic-core==2.23.4
+      - pydantic-settings==2.6.0
+      - pydeck==0.9.1
+      - pygments==2.18.0
+      - pypika==0.48.9
+      - pyproject-hooks==1.2.0
+      - python-dateutil==2.9.0.post0
+      - python-dotenv==1.0.1
+      - pytz==2024.2
+      - pyyaml==6.0.2
+      - referencing==0.35.1
+      - regex==2024.9.11
+      - requests==2.32.3
+      - requests-oauthlib==2.0.0
+      - requests-toolbelt==1.0.0
+      - rich==13.9.3
+      - rpds-py==0.20.0
+      - rsa==4.9
+      - safetensors==0.4.5
+      - scikit-learn==1.5.2
+      - scipy==1.13.1
+      - sentence-transformers==3.2.1
+      - shellingham==1.5.4
+      - six==1.16.0
+      - smmap==5.0.1
+      - sniffio==1.3.1
+      - sqlalchemy==2.0.36
+      - starlette==0.41.0
+      - streamlit==1.39.0
+      - sympy==1.13.1
+      - tenacity==9.0.0
+      - threadpoolctl==3.5.0
+      - tokenizers==0.20.1
+      - toml==0.10.2
+      - tomli==2.0.2
+      - torch==2.5.0
+      - tornado==6.4.1
+      - tqdm==4.66.5
+      - transformers==4.46.0
+      - typer==0.12.5
+      - typing-extensions==4.12.2
+      - typing-inspect==0.9.0
+      - tzdata==2024.2
+      - urllib3==2.2.3
+      - uvicorn==0.32.0
+      - uvloop==0.21.0
+      - watchfiles==0.24.0
+      - websocket-client==1.8.0
+      - websockets==13.1
+      - wrapt==1.16.0
+      - yarl==1.16.0
+      - zipp==3.20.2

pages/FSR_Model.py

@@ -0,0 +1,944 @@
+import uuid
+import streamlit as st
+from openai import AzureOpenAI
+import firebase_admin
+from firebase_admin import credentials, firestore
+from typing import Dict, Any
+import time
+import os
+import tempfile
+import json
+
+from utils.prompt_utils import PERSONA_PREFIX, baseline, baseline_esp, fs, RAG, EMOTIONAL_PROMPT, CLASSIFICATION_PROMPT, INFORMATIONAL_PROMPT
+from utils.RAG_utils import load_or_create_vectorstore
+
+# PERSONA_PREFIX = ""
+# baseline = ""
+# baseline_esp = ""
+# fs = ""
+# RAG = ""
+# EMOTIONAL_PROMPT = ""
+# CLASSIFICATION_PROMPT = """
+# Determine si esta afirmación busca empatía o (1) o busca información (0).
+# Clasifique como emocional sólo si la pregunta expresa preocupación, ansiedad o malestar sobre el estado de salud del paciente.
+# En caso contrario, clasificar como informativo.
+
+# Ejemplos:
+# - Pregunta: Me siento muy ansioso por mi diagnóstico de tuberculosis. 1
+# - Pregunta: ¿Cuáles son los efectos secundarios comunes de los medicamentos contra la tuberculosis? 0
+# - Pregunta: Estoy preocupada porque tengo mucho dolor. 1
+# - Pregunta: ¿Es seguro tomar medicamentos como analgésicos junto con medicamentos para la tuberculosis? 0
+
+# Aquí está la declaración para clasificar. Simplemente responda con el número "1" o "0":
+# """
+
+# INFORMATIONAL_PROMPT = ""
+
+# Model configurations remain the same
+MODEL_CONFIGS = {
+    # "Model 0: Naive English Baseline Model": {
+    #     "name": "Model 0: Naive English Baseline Model",
+    #     "prompt": PERSONA_PREFIX + baseline,
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 1: Naive Spanish Baseline Model": {
+    #     "name": "Model 1: Baseline Model",
+    #     "prompt": PERSONA_PREFIX + baseline_esp,
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 1": {
+    #     "name": "Model 1: Few_Shot model",
+    #     "prompt": PERSONA_PREFIX + fs,
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 3: RAG Model": {F
+    #     "name": "Model 3: RAG Model",
+    #     "prompt": PERSONA_PREFIX + RAG,
+    #     "uses_rag": True,
+    #     "uses_classification": False
+    # },
+    "Model 2": {
+        "name": "Model 2: RAG + Few_Shot Model",
+        "prompt": PERSONA_PREFIX + RAG + fs,
+        "uses_rag": True,
+        "uses_classification": False
+    },
+    # "Model 3": {
+    #     "name": "Model 3: 2-Stage Classification Model",
+    #     "prompt": PERSONA_PREFIX + INFORMATIONAL_PROMPT,  # default
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 6: Multi-Agent": {
+    #     "name": "Model 6: Multi-Agent",
+    #     "prompt": PERSONA_PREFIX + INFORMATIONAL_PROMPT,  # default
+    #     "uses_rag": True,
+    #     "uses_classification": True,
+    #     "uses_judges": True
+    # }
+}
+PASSCODE = os.environ["MY_PASSCODE"]
+
+# # Authentication check
+# if "authenticated" not in st.session_state or not st.session_state["authenticated"]:
+#     st.error("Access denied. Please go back to the main page and enter the passcode.")
+#     st.stop()
+
+# Initialize Firebase
+if not firebase_admin._apps:
+    cred = credentials.Certificate("coco-evaluation-firebase-adminsdk-p3m64-99c4ea22c1.json")
+    firebase_admin.initialize_app(cred)
+db = firestore.client()
+
+endpoint = os.environ["ENDPOINT_URL"]
+deployment = os.environ["DEPLOYMENT"]
+subscription_key = os.environ["subscription_key"]
+
+# OpenAI API setup
+client = AzureOpenAI(
+    azure_endpoint=endpoint,
+    api_key=subscription_key,
+    api_version=os.environ["api_version"]
+)
+
+def authenticate():
+    creds_dict = {
+        "type": os.environ.get("FIREBASE_TYPE", "service_account"),
+        "project_id": os.environ.get("FIREBASE_PROJECT_ID"),
+        "private_key_id": os.environ.get("FIREBASE_PRIVATE_KEY_ID"),
+        "private_key": os.environ.get("FIREBASE_PRIVATE_KEY", "").replace("\\n", "\n"),
+        "client_email": os.environ.get("FIREBASE_CLIENT_EMAIL"),
+        "client_id": os.environ.get("FIREBASE_CLIENT_ID"),
+        "auth_uri": os.environ.get("FIREBASE_AUTH_URI", "https://accounts.google.com/o/oauth2/auth"),
+        "token_uri": os.environ.get("FIREBASE_TOKEN_URI", "https://oauth2.googleapis.com/token"),
+        "auth_provider_x509_cert_url": os.environ.get("FIREBASE_AUTH_PROVIDER_X509_CERT_URL", 
+                                                    "https://www.googleapis.com/oauth2/v1/certs"),
+        "client_x509_cert_url": os.environ.get("FIREBASE_CLIENT_X509_CERT_URL"),
+        "universe_domain": "googleapis.com"
+
+    }
+    # Create a temporary JSON file
+    with tempfile.NamedTemporaryFile(suffix='.json', delete=False, mode='w') as temp_file:
+        json.dump(creds_dict, temp_file)
+        temp_file.close()
+
+    import uuid
+    
+    random_id = uuid.uuid4()
+    random_id_string = str(random_id)
+    evaluator_id = random_id_string
+    db = firestore.client()
+    db.collection("evaluator_ids").document(evaluator_id).set({
+        "evaluator_id": evaluator_id,
+        "timestamp": firestore.SERVER_TIMESTAMP
+    })
+
+    # Update session state
+    st.session_state["authenticated"] = True
+    st.session_state["evaluator_id"] = evaluator_id
+
+def init():
+    """Initialize all necessary components and state variables"""
+    # Initialize Firebase if not already initialized
+    if not firebase_admin._apps:
+        cred = credentials.Certificate("coco-evaluation-firebase-adminsdk-p3m64-99c4ea22c1.json")
+        firebase_admin.initialize_app(cred)
+    
+    # Initialize session state variables
+    if "messages" not in st.session_state:
+        st.session_state.messages = {}
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = str(uuid.uuid4())
+    if "chat_active" not in st.session_state:
+        st.session_state.chat_active = False
+    if "user_input" not in st.session_state:
+        st.session_state.user_input = ""
+    if "user_id" not in st.session_state:
+        st.session_state.user_id = f"anonymous_{str(uuid.uuid4())}"
+    if "selected_model" not in st.session_state:
+        st.session_state.selected_model = list(MODEL_CONFIGS.keys())[0]
+    if "model_profile" not in st.session_state:
+        st.session_state.model_profile = [0, 0]
+    
+    # Load vectorstore at startup
+    if "vectorstore" not in st.session_state:
+        with st.spinner("Loading document embeddings..."):
+            st.session_state.vectorstore = load_or_create_vectorstore()
+
+def get_classification(client, deployment, user_input):
+    """Classify the input as emotional (1) or informational (0)"""
+    chat_prompt = [
+        {"role": "system", "content": CLASSIFICATION_PROMPT},
+        {"role": "user", "content": user_input}
+    ]
+
+    completion = client.chat.completions.create(
+        model=deployment,
+        messages=chat_prompt,
+        max_tokens=1,
+        temperature=0,
+        top_p=0.9,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+    
+    return completion.choices[0].message.content.strip()
+def process_input():
+    try:
+        current_model = st.session_state.selected_model
+        user_input = st.session_state.user_input
+        
+        if not user_input.strip():
+            st.warning("Please enter a message before sending.")
+            return
+            
+        model_config = MODEL_CONFIGS.get(current_model)
+        if not model_config:
+            st.error("Invalid model selected. Please choose a valid model.")
+            return
+
+        if current_model not in st.session_state.messages:
+            st.session_state.messages[current_model] = []
+
+        st.session_state.messages[current_model].append({"role": "user", "content": user_input})
+        
+        try:
+            log_message("user", user_input)
+        except Exception as e:
+            st.warning(f"Failed to log message: {str(e)}")
+            
+        conversation_history = "\n".join([f"{msg['role'].capitalize()}: {msg['content']}" 
+                                        for msg in st.session_state.messages[current_model]])
+
+        # Helper function for error handling in API calls
+        def safe_api_call(messages, max_retries=3):
+            for attempt in range(max_retries):
+                try:
+                    response = client.chat.completions.create(
+                        model=deployment,
+                        messages=messages,
+                        max_tokens=3500,
+                        temperature=0.1,
+                        top_p=0.9
+                    )
+                    return response.choices[0].message.content.strip()
+                except Exception as e:
+                    if attempt == max_retries - 1:
+                        raise Exception(f"Failed to get response after {max_retries} attempts: {str(e)}")
+                    st.warning(f"Attempt {attempt + 1} failed, retrying...")
+                    time.sleep(1)
+
+        def perform_rag_query(input_text, conversation_history):
+            try:
+                relevant_docs = retrieve_relevant_documents(
+                    st.session_state.vectorstore, 
+                    input_text, 
+                    conversation_history,
+                    client=client
+                )
+                
+                model_messages = [
+                    {"role": "system", "content": f"{model_config['prompt']}\n\nContexto: {relevant_docs}"}
+                ] + st.session_state.messages[current_model]
+                
+                return safe_api_call(model_messages), relevant_docs
+                
+            except Exception as e:
+                st.error(f"Error in RAG query: {str(e)}")
+                return "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente.", ""
+
+        initial_response = None
+        initial_docs = ""
+
+        # Handle 2-stage model
+        if model_config.get('uses_classification', False):
+            try:
+                classification = get_classification(client, deployment, user_input)
+                
+                if 'classifications' not in st.session_state:
+                    st.session_state.classifications = {}
+                st.session_state.classifications[len(st.session_state.messages[current_model]) - 1] = classification
+
+                if classification == "0":
+                    initial_response, initial_docs = perform_rag_query(user_input, conversation_history)
+                else:
+                    model_messages = [
+                        {"role": "system", "content": PERSONA_PREFIX + EMOTIONAL_PROMPT}
+                    ] + st.session_state.messages[current_model]
+                    initial_response = safe_api_call(model_messages)
+                    
+            except Exception as e:
+                st.error(f"Error in classification stage: {str(e)}")
+                initial_response = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+
+        # Handle RAG models
+        if model_config.get('uses_rag', False):
+            try:
+                if not initial_response:
+                    initial_response, initial_docs = perform_rag_query(user_input, conversation_history)
+
+                verification_docs = retrieve_relevant_documents(
+                    st.session_state.vectorstore, 
+                    initial_response,
+                    conversation_history,
+                    client=client
+                )
+
+                combined_docs = initial_docs + "\nContexto de verificación adicional:\n" + verification_docs
+
+                verification_messages = [
+                    {
+                        "role": "system", 
+                        "content": f"Pregunta del paciente:{user_input} \nContexto: {combined_docs} \nRespuesta anterior: {initial_response}\n Verifique la precisión médica de la respuesta anterior y refine la respuesta según el contexto adicional."
+                    }
+                ]
+
+                assistant_reply = safe_api_call(verification_messages)
+                
+            except Exception as e:
+                st.error(f"Error in RAG processing: {str(e)}")
+                assistant_reply = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+        else:
+            try:
+                model_messages = [
+                    {"role": "system", "content": model_config['prompt']}
+                ] + st.session_state.messages[current_model]
+                
+                assistant_reply = safe_api_call(model_messages)
+                
+            except Exception as e:
+                st.error(f"Error generating response: {str(e)}")
+                assistant_reply = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+
+        # Store and log the final response
+        try:
+            st.session_state.messages[current_model].append({"role": "assistant", "content": assistant_reply})
+            log_message("assistant", assistant_reply)
+            # store_conversation_data()
+        except Exception as e:
+            st.warning(f"Failed to store or log response: {str(e)}")
+
+        st.session_state.user_input = ""
+        
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)}")
+        st.session_state.user_input = ""
+
+
+def check_document_relevance(query, doc, client):
+    """
+    Check document relevance using few-shot prompting for Spanish TB context.
+    
+    Args:
+        query (str): The user's input query
+        doc (str): The retrieved document text
+        client: The OpenAI client instance
+    
+    Returns:
+        bool: True if document is relevant, False otherwise
+    """
+    few_shot_prompt = f"""Determine si el documento es relevante para la consulta sobre tuberculosis.
+        Responde únicamente 'sí' si es relevante o 'no' si no es relevante.
+        Ejemplos:
+        Consulta: ¿Cuáles son los efectos secundarios de la rifampicina?
+        Documento: La rifampicina puede causar efectos secundarios como náuseas, vómitos y coloración naranja de fluidos corporales. Es importante tomar el medicamento con el estómago vacío.
+        Respuesta: sí
+        Consulta: ¿Cuánto dura el tratamiento de TB?
+        Documento: El dengue es una enfermedad viral transmitida por mosquitos. Los síntomas incluyen fiebre alta y dolor muscular.
+        Respuesta: no
+        Consulta: ¿Cómo se realiza la prueba de esputo?
+        Documento: Para la prueba de esputo, el paciente debe toser profundamente para obtener una muestra de las vías respiratorias. La muestra debe recogerse en ayunas.
+        Respuesta: sí
+        Consulta: ¿Qué medidas de prevención debo tomar en casa?
+        Documento: Mayo Clinic tiene una gran cantidad de pacientes que atender.
+        Respuesta: no
+        Consulta: {query}
+        Documento: {doc}
+        Respuesta:"""
+    
+    response = client.chat.completions.create(
+        model=deployment,
+        messages=[{"role": "user", "content": few_shot_prompt}],
+        max_tokens=3,
+        temperature=0.1,
+        top_p=0.9
+    )
+    
+    return response.choices[0].message.content.strip().lower() == "sí"
+
+# In retrieve_relevant_documents function
+def retrieve_relevant_documents(vectorstore, query, conversation_history, client, top_k=3, score_threshold=0.5):
+    if not vectorstore:
+        st.error("Vector store not initialized")
+        return ""
+        
+    try:
+        recent_history = "\n".join(conversation_history.split("\n")[-3:]) if conversation_history else ""
+        full_query = query
+        if len(recent_history) < 200:
+            full_query = f"{recent_history} {query}".strip()
+        
+        results = vectorstore.similarity_search_with_score(
+            full_query,
+            k=top_k,
+            distance_metric="cos"
+        )
+        
+        if not results:
+            return "No se encontraron documentos relevantes."
+        
+        # Handle case where results don't include scores
+        if results and not isinstance(results[0], tuple):
+            # If results are just documents without scores, assign a default score
+            score_filtered_results = [(doc, 1.0) for doc in results]
+        else:
+            # Filter by similarity score
+            score_filtered_results = [
+                (result, score) for result, score in results 
+                if score > score_threshold
+            ]
+        
+        # Apply relevance checking to remaining documents
+        relevant_results = []
+        for result, score in score_filtered_results:
+            if check_document_relevance(query, result.page_content, client):
+                relevant_results.append((result, score))
+        
+        # Fallback to default context if no relevant docs found
+        if not relevant_results:
+            if score_filtered_results:
+                print("No relevant documents found after relevance check.")
+                return "Eres un modelo de IA centrado en la tuberculosis."
+            return ""
+        
+        # Format results
+        combined_results = [
+            f"Document excerpt (score: {score:.2f}):\n{result.page_content}"
+            for result, score in relevant_results
+        ]
+        
+        return "\n\n".join(combined_results)
+        
+    except Exception as e:
+        st.error(f"Error retrieving documents: {str(e)}")
+        return "Error al buscar documentos relevantes."
+
+def store_conversation_data():
+    current_model = st.session_state.selected_model
+    model_config = MODEL_CONFIGS[current_model]
+    
+    doc_ref = db.collection('conversations').document(str(st.session_state.session_id))
+    doc_ref.set({
+        'timestamp': firestore.SERVER_TIMESTAMP,
+        'userID': st.session_state.user_id,
+        'model_index': list(MODEL_CONFIGS.keys()).index(current_model) + 1,
+        'profile_index': st.session_state.model_profile[1],
+        'profile': '',
+        'conversation': st.session_state.messages[current_model],
+        'uses_rag': model_config['uses_rag']
+    })
+
+def log_message(role, content):
+    current_model = st.session_state.selected_model
+    model_config = MODEL_CONFIGS[current_model]
+    collection_name = f"messages_model_{list(MODEL_CONFIGS.keys()).index(current_model) + 1}"
+    
+    doc_ref = db.collection(collection_name).document()
+    doc_ref.set({
+        'timestamp': firestore.SERVER_TIMESTAMP,
+        'session_id': str(st.session_state.session_id),
+        'userID': st.session_state.get('user_id', 'anonymous'),
+        'role': role,
+        'content': content,
+        'model_name': model_config['name']
+    })
+
+def reset_conversation():
+    current_model = st.session_state.selected_model
+    
+    if current_model in st.session_state.messages and st.session_state.messages[current_model]:
+        doc_ref = db.collection('conversation_ends').document()
+        doc_ref.set({
+            'timestamp': firestore.SERVER_TIMESTAMP,
+            'session_id': str(st.session_state.session_id),
+            'userID': st.session_state.get('user_id', 'anonymous'),
+            'total_messages': len(st.session_state.messages[current_model]),
+            'model_name': MODEL_CONFIGS[current_model]['name']
+        })
+    
+    st.session_state.messages[current_model] = []
+    st.session_state.session_id = str(uuid.uuid4())
+    st.session_state.chat_active = False
+    st.query_params.clear()
+
+class ModelEvaluationSystem:
+    def __init__(self, db: firestore.Client):
+        self.db = db
+        self.models_to_evaluate = list(MODEL_CONFIGS.keys())  # Use existing MODEL_CONFIGS
+        self._initialize_state()
+        self._load_existing_evaluations()
+
+    def _initialize_state(self):
+        """Initialize or load evaluation state."""
+        if "evaluation_state" not in st.session_state:
+            st.session_state.evaluation_state = {}
+
+        if "evaluated_models" not in st.session_state:
+            st.session_state.evaluated_models = {}
+
+    def _get_current_user_id(self):
+        """
+        Get current user identifier.
+        """
+        return st.session_state["evaluator_id"]
+
+    def render_evaluation_progress(self):
+        """
+        Render evaluation progress in the sidebar.
+        """
+        st.sidebar.header("Evaluation Progress")
+        
+        # Calculate progress
+        total_models = len(self.models_to_evaluate)
+        evaluated_models = len(st.session_state.evaluated_models)
+        
+        # Progress bar
+        st.sidebar.progress(evaluated_models / total_models)
+        
+        # List of models and their status
+        for model in self.models_to_evaluate:
+            status = "✅ Completed" if st.session_state.evaluated_models.get(model, False) else "⏳ Pending"
+            st.sidebar.markdown(f"{model}: {status}")
+        
+        # Check if all models are evaluated
+        if evaluated_models == total_models:
+            self._render_completion_screen()
+
+    def _load_existing_evaluations(self):
+        """
+        Load existing evaluations from Firestore for the current user/session.
+        """
+        try:
+            user_id = self._get_current_user_id()
+            
+            existing_evals = self.db.collection('model_evaluations').document(user_id).get()
+            
+            if existing_evals.exists:
+                loaded_data = existing_evals.to_dict()
+                
+                # Populate evaluated models from existing data
+                for model, eval_data in loaded_data.get('evaluations', {}).items():
+                    if eval_data.get('status') == 'complete':
+                        st.session_state.evaluated_models[model] = True
+                    
+                    # Restore slider and text area values
+                    st.session_state[f"performance_slider_{model}"] = eval_data.get('overall_score', 5)
+                    
+                    for dimension, dim_data in eval_data.get('dimension_evaluations', {}).items():
+                        dim_key = dimension.lower().replace(' ', '_')
+                        st.session_state[f"{dim_key}_score_{model}"] = dim_data.get('score', 5)
+                        
+                        if dim_data.get('follow_up_reason'):
+                            st.session_state[f"follow_up_reason_{dim_key}_{model}"] = dim_data['follow_up_reason']
+        
+        except Exception as e:
+            st.error(f"Error loading existing evaluations: {e}")
+
+    def render_evaluation_sidebar(self, selected_model):
+        """
+        Render evaluation sidebar for the selected model, including the Empathy section.
+        """
+        # Evaluation dimensions based on the QUEST framework
+        dimensions = {
+            "Accuracy": "The answers provided by the chatbot were medically accurate and contained no errors",
+            "Comprehensiveness": "The answers are comprehensive and are not missing important information",
+            "Helpfulness to the Human Responder": "The answers are helpful to the human responder and require minimal or no edits before sending them to the patient",
+            "Understanding": "The chatbot was able to understand my questions and responded appropriately to the questions asked",
+            "Clarity": "The chatbot was able to provide answers that patients would be able to understand for their level of medical literacy",
+            "Language": "The chatbot provided answers that were idiomatically appropriate and are indistinguishable from those produced by native Spanish speakers",
+            "Harm": "The answers provided do not contain information that would lead to patient harm or negative outcomes",
+            "Fabrication": "The chatbot provided answers that were free of hallucinations, fabricated information, or other information that was not based or evidence-based medical practice",
+            "Trust": "The chatbot provided responses that are similar to those that would be provided by an expert or healthcare professional with experience in treating tuberculosis"
+        }
+
+        empathy_statements = [
+            "Response included expression of emotions, such as warmth, compassion, and concern or similar towards the patient (i.e. Todo estará bien. / Everything will be fine).",
+            "Response communicated an understanding of feelings and experiences interpreted from the patient's responses (i.e. Entiendo su preocupación. / I understand your concern).",
+            "Response aimed to improve understanding by exploring the feelings and experiences of the patient (i.e. Cuénteme más de cómo se está sintiendo. / Tell me more about how you are feeling.)"
+        ]
+
+        st.sidebar.subheader(f"Evaluate {selected_model}")
+
+        # Overall model performance evaluation
+        overall_score = st.sidebar.slider(
+            "Overall Model Performance", 
+            min_value=1, 
+            max_value=10, 
+            value=st.session_state.get(f"performance_slider_{selected_model}", 5), 
+            key=f"performance_slider_{selected_model}",
+            on_change=self._track_evaluation_change,
+            args=(selected_model, 'overall_score')
+        )
+
+        # Dimension evaluations
+        dimension_evaluations = {}
+        all_questions_answered = True
+
+        for dimension in dimensions.keys():
+            st.sidebar.markdown(f"**{dimension} Evaluation**")
+
+            # Define the Likert scale options
+            likert_options = {
+                "Strongly Disagree": 1,
+                "Disagree": 2,
+                "Neutral": 3,
+                "Agree": 4,
+                "Strongly Agree": 5
+            }
+
+            # Get the current value and convert it to the corresponding text option
+            current_value = st.session_state.get(f"{dimension.lower().replace(' ', '_')}_score_{selected_model}", 3)
+            current_text = [k for k, v in likert_options.items() if v == current_value][0]
+
+            # Create the selectbox for rating
+            dimension_text_score = st.sidebar.selectbox(
+                f"{dimensions[dimension]} Rating",
+                options=list(likert_options.keys()),
+                index=list(likert_options.keys()).index(current_text),
+                key=f"{dimension.lower().replace(' ', '_')}_score_text_{selected_model}",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, dimension)
+            )
+
+            # Convert text score back to numeric value for storage
+            dimension_score = likert_options[dimension_text_score]
+
+            # Conditional follow-up for disagreement scores
+            if dimension_score < 4:
+                follow_up_question = "Please, provide an example or description for your feedback."
+                feedback_type = "disagreement"
+
+                follow_up_reason = st.sidebar.text_area(
+                    follow_up_question, 
+                    value=st.session_state.get(f"follow_up_reason_{dimension.lower().replace(' ', '_')}_{selected_model}", ""),
+                    key=f"follow_up_reason_{dimension.lower().replace(' ', '_')}_{selected_model}",
+                    help=f"Please provide specific feedback about the model's performance in {dimension}",
+                    on_change=self._track_evaluation_change,
+                    args=(selected_model, f"{dimension}_feedback")
+                )
+
+                # Check if the follow-up question was answered
+                if not follow_up_reason:
+                    all_questions_answered = False
+
+                dimension_evaluations[dimension] = {
+                    "score": dimension_score,
+                    "feedback_type": feedback_type,
+                    "follow_up_reason": follow_up_reason
+                }
+            else:
+                dimension_evaluations[dimension] = {
+                    "score": dimension_score,
+                    "feedback_type": "neutral_or_positive",
+                    "follow_up_reason": None
+                }
+
+        st.sidebar.markdown(f"**Empathy Section**")
+        st.sidebar.markdown("<small><a href='https://docs.google.com/document/d/1Olqfo14Zde_GXXWAPzG0OiYUE53nc_I3/edit?usp=sharing&ouid=107404473110455439345&rtpof=true&sd=true' target='_blank'>Look here for example ratings</a></small>", unsafe_allow_html=True)
+
+        # Empathy section with updated scale
+        empathy_evaluations = {}
+        empathy_likert_options = {
+            "No expression of an empathetic response": 1,
+            "Expressed empathetic response to a weak degree": 2,
+            "Expressed empathetic response strongly": 3
+        }
+
+        for i, _ in enumerate(empathy_statements, 1):
+            st.sidebar.markdown(f"**Empathy Evaluation {i}:**")
+
+            # Get current value and convert to text
+            current_value = st.session_state.get(f"empathy_score_{i}_{selected_model}", 1)
+            current_text = [k for k, v in empathy_likert_options.items() if v == current_value][0]
+
+            empathy_text_score = st.sidebar.selectbox(
+                f"How strongly do you agree with the following statement for empathy: {empathy_statements[i-1]}?",
+                options=list(empathy_likert_options.keys()),
+                index=list(empathy_likert_options.keys()).index(current_text),
+                key=f"empathy_score_text_{i}_{selected_model}",
+                help=f"Please rate how empathetic the response was based on statement.",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, f"empathy_score_{i}")
+            )
+
+            # Convert text score back to numeric value
+            empathy_score = empathy_likert_options[empathy_text_score]
+
+            follow_up_question = f"Please provide a brief rationale for your rating:"
+            follow_up_reason = st.sidebar.text_area(
+                follow_up_question, 
+                value=st.session_state.get(f"follow_up_reason_empathy_{i}_{selected_model}", ""),
+                key=f"follow_up_reason_empathy_{i}_{selected_model}",
+                help="Please explain why you gave this rating.",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, f"empathy_{i}_feedback")
+            )
+
+            # Check if the follow-up question was answered
+            if not follow_up_reason:
+                all_questions_answered = False
+
+            empathy_evaluations[f"statement_{i}"] = {
+                "score": empathy_score,
+                "follow_up_reason": follow_up_reason
+            }
+
+        # Add extra feedback section
+        st.sidebar.markdown("**Additional Feedback**")
+        extra_feedback = st.sidebar.text_area(
+            "Extra feedback, e.g. whether it is similar or too different with some other model",
+            value=st.session_state.get(f"extra_feedback_{selected_model}", ""),
+            key=f"extra_feedback_{selected_model}",
+            help="Please provide any additional comments or comparisons with other models.",
+            on_change=self._track_evaluation_change,
+            args=(selected_model, "extra_feedback")
+        )
+
+        # Submit evaluation button
+        submit_disabled = not all_questions_answered
+
+        submit_button = st.sidebar.button(
+            "Submit Evaluation", 
+            key=f"submit_evaluation_{selected_model}",
+            disabled=submit_disabled
+        )
+
+        if submit_button:
+            # Prepare comprehensive evaluation data
+            evaluation_data = {
+                "model": selected_model,
+                "overall_score": overall_score,
+                "dimension_evaluations": dimension_evaluations,
+                "empathy_evaluations": empathy_evaluations,
+                "extra_feedback": extra_feedback,
+                "status": "complete"
+            }
+
+            self.save_model_evaluation(evaluation_data)
+
+            # Mark model as evaluated
+            st.session_state.evaluated_models[selected_model] = True
+
+            st.sidebar.success("Evaluation submitted successfully!")
+
+            # Render progress to check for completion
+            self.render_evaluation_progress()
+
+
+    def _track_evaluation_change(self, model: str, change_type: str):
+        """
+        Track changes in evaluation fields in real-time.
+        """
+        try:
+            # Prepare evaluation data
+            evaluation_data = {
+                "model": model,
+                "overall_score": st.session_state.get(f"performance_slider_{model}", 5),
+                "dimension_evaluations": {},
+                "status": "in_progress"
+            }
+            
+            # Dimensions to check
+            dimensions = [
+                "Accuracy",
+                "Coherence", 
+                "Relevance", 
+                "Creativity", 
+                "Ethical Considerations"
+            ]
+            
+            # Populate dimension evaluations
+            for dimension in dimensions:
+                dim_key = dimension.lower().replace(' ', '_')
+                evaluation_data["dimension_evaluations"][dimension] = {
+                    "score": st.session_state.get(f"{dim_key}_score_{model}", 5),
+                    "follow_up_reason": st.session_state.get(f"follow_up_reason_{dim_key}_{model}", "")
+                }
+            
+            # Save partial evaluation
+            self.save_model_evaluation(evaluation_data)
+        
+        except Exception as e:
+            st.error(f"Error tracking evaluation change: {e}")
+
+    def save_model_evaluation(self, evaluation_data: Dict[str, Any]):
+        """
+        Save the model evaluation data to the database.
+        """
+        try:
+            # Get current user ID (replace with actual method)
+            user_id = self._get_current_user_id()
+            
+            # Create or update document in Firestore
+            user_eval_ref = self.db.collection('model_evaluations').document(user_id)
+            
+            # Update or merge the evaluation for this specific model
+            user_eval_ref.set({
+                'evaluations': {
+                    evaluation_data['model']: evaluation_data
+                }
+            }, merge=True)
+            
+            st.toast(f"Evaluation for {evaluation_data['model']} saved {'completely' if evaluation_data.get('status') == 'complete' else 'partially'}")
+        
+        except Exception as e:
+            st.error(f"Error saving evaluation: {e}")
+
+    def _render_completion_screen(self):
+        """
+        Render a completion screen when all models are evaluated.
+        """
+        # Clear the main content area
+        st.empty()
+        
+        # Display completion message
+        st.balloons()
+        st.title("🎉 Evaluation Complete!")
+        st.markdown("Thank you for your valuable feedback.")
+        
+        # Reward link (replace with actual reward link)
+        st.markdown("### Claim Your Reward")
+        st.markdown("""
+        Click the button below to receive your reward:
+        
+        [🎁 Claim Reward](https://example.com/reward)
+        """)
+        
+        # Optional: Log completion event
+        self._log_evaluation_completion()
+
+    def _log_evaluation_completion(self):
+        """
+        Log the completion of all model evaluations.
+        """
+        try:
+            user_id = self._get_current_user_id()
+            
+            # Log completion timestamp
+            completion_log_ref = self.db.collection('evaluation_completions').document(user_id)
+            completion_log_ref.set({
+                'completed_at': firestore.SERVER_TIMESTAMP,
+                'models_evaluated': list(self.models_to_evaluate)
+            })
+        
+        except Exception as e:
+            st.error(f"Error logging evaluation completion: {e}")
+
+def main():
+    try:
+        authenticate()
+        init()
+        
+        # Initialize evaluation system
+        # evaluation_system = ModelEvaluationSystem(db)
+        
+        st.title("Chat with AI Models")
+        # Sidebar configuration
+        with st.sidebar:
+            st.header("Settings")
+    
+            # Function to call reset_conversation when the model selection changes
+            def on_model_change():
+                try:
+                    reset_conversation()
+                except Exception as e:
+                    st.error(f"Error resetting conversation: {str(e)}")
+    
+            selected_model = st.selectbox(
+                "Select Model",
+                options=list(MODEL_CONFIGS.keys()),
+                key="model_selector",
+                on_change=on_model_change
+            )
+            
+            if selected_model not in MODEL_CONFIGS:
+                st.error("Invalid model selected")
+                return
+                
+            st.session_state.selected_model = selected_model
+    
+            if st.button("Reset Conversation", key="reset_button"):
+                try:
+                    reset_conversation()
+                except Exception as e:
+                    st.error(f"Error resetting conversation: {str(e)}")
+    
+            # Add evaluation sidebar
+            # evaluation_system.render_evaluation_sidebar(selected_model)
+    
+            with st.expander("Instructions"):
+                st.write("""
+                **How to Use the Chatbot Interface:**
+                1. **Choose the assigned model**: Choose the model to chat with that was assigned in the Qualtrics.
+                2. **Chat with GPT-4**: Enter your messages in the input box to chat with the assistant.
+                3. **Reset Conversation**: Click "Reset Conversation" to clear chat history and start over.
+                """)
+        
+        chat_container = st.container()
+        
+        with chat_container:
+            if not st.session_state.chat_active:
+                st.session_state.chat_active = True
+            
+            if selected_model in st.session_state.messages:
+                message_pairs = []
+                # Group messages into pairs (user + assistant)
+                for i in range(0, len(st.session_state.messages[selected_model]), 2):
+                    if i + 1 < len(st.session_state.messages[selected_model]):
+                        message_pairs.append((
+                            st.session_state.messages[selected_model][i],
+                            st.session_state.messages[selected_model][i + 1]
+                        ))
+                    else:
+                        message_pairs.append((
+                            st.session_state.messages[selected_model][i],
+                            None
+                        ))
+                
+                # Display message pairs with turn numbers
+                for turn_num, (user_msg, assistant_msg) in enumerate(message_pairs, 1):
+                    # Display user message
+                    col1, col2 = st.columns([0.9, 0.1])
+                    with col1:
+                        with st.chat_message(user_msg["role"]):
+                            st.write(user_msg["content"])
+                            # Show classification for Model 3
+                            if (selected_model == "Model 3" and 
+                                'classifications' in st.session_state):
+                                idx = (turn_num - 1) * 2
+                                if idx in st.session_state.classifications:
+                                    classification = "Emotional" if st.session_state.classifications[idx] == "1" else "Informational"
+                                    st.caption(f"Message classified as: {classification}")
+                    with col2:
+                        st.write(f"{turn_num}")
+                    
+                    # Display assistant message if it exists
+                    if assistant_msg:
+                        with st.chat_message(assistant_msg["role"]):
+                            st.write(assistant_msg["content"])
+                        
+            st.text_input(
+                "Type your message here...",
+                key="user_input",
+                value="",
+                on_change=process_input
+            )
+    except Exception as e:
+        st.error(f"An unexpected error occurred in the main application: {str(e)}")
+
+if __name__ == "__main__":
+    main()

pages/FS_Model.py

@@ -0,0 +1,944 @@
+import uuid
+import streamlit as st
+from openai import AzureOpenAI
+import firebase_admin
+from firebase_admin import credentials, firestore
+from typing import Dict, Any
+import time
+import os
+import tempfile
+import json
+
+from utils.prompt_utils import PERSONA_PREFIX, baseline, baseline_esp, fs, RAG, EMOTIONAL_PROMPT, CLASSIFICATION_PROMPT, INFORMATIONAL_PROMPT
+from utils.RAG_utils import load_or_create_vectorstore
+
+# PERSONA_PREFIX = ""
+# baseline = ""
+# baseline_esp = ""
+# fs = ""
+# RAG = ""
+# EMOTIONAL_PROMPT = ""
+# CLASSIFICATION_PROMPT = """
+# Determine si esta afirmación busca empatía o (1) o busca información (0).
+# Clasifique como emocional sólo si la pregunta expresa preocupación, ansiedad o malestar sobre el estado de salud del paciente.
+# En caso contrario, clasificar como informativo.
+
+# Ejemplos:
+# - Pregunta: Me siento muy ansioso por mi diagnóstico de tuberculosis. 1
+# - Pregunta: ¿Cuáles son los efectos secundarios comunes de los medicamentos contra la tuberculosis? 0
+# - Pregunta: Estoy preocupada porque tengo mucho dolor. 1
+# - Pregunta: ¿Es seguro tomar medicamentos como analgésicos junto con medicamentos para la tuberculosis? 0
+
+# Aquí está la declaración para clasificar. Simplemente responda con el número "1" o "0":
+# """
+
+# INFORMATIONAL_PROMPT = ""
+
+# Model configurations remain the same
+MODEL_CONFIGS = {
+    # "Model 0: Naive English Baseline Model": {
+    #     "name": "Model 0: Naive English Baseline Model",
+    #     "prompt": PERSONA_PREFIX + baseline,
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 1: Naive Spanish Baseline Model": {
+    #     "name": "Model 1: Baseline Model",
+    #     "prompt": PERSONA_PREFIX + baseline_esp,
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    "Model 1": {
+        "name": "Model 1: Few_Shot model",
+        "prompt": PERSONA_PREFIX + fs,
+        "uses_rag": False,
+        "uses_classification": False
+    },
+    # "Model 3: RAG Model": {F
+    #     "name": "Model 3: RAG Model",
+    #     "prompt": PERSONA_PREFIX + RAG,
+    #     "uses_rag": True,
+    #     "uses_classification": False
+    # },
+    # "Model 2: RAG + FS Model": {
+    #     "name": "Model 2: RAG + Few_Shot Model",
+    #     "prompt": PERSONA_PREFIX + RAG + fs,
+    #     "uses_rag": True,
+    #     "uses_classification": False
+    # },
+    # "Model 3": {
+    #     "name": "Model 3: 2-Stage Classification Model",
+    #     "prompt": PERSONA_PREFIX + INFORMATIONAL_PROMPT,  # default
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 6: Multi-Agent": {
+    #     "name": "Model 6: Multi-Agent",
+    #     "prompt": PERSONA_PREFIX + INFORMATIONAL_PROMPT,  # default
+    #     "uses_rag": True,
+    #     "uses_classification": True,
+    #     "uses_judges": True
+    # }
+}
+PASSCODE = os.environ["MY_PASSCODE"]
+
+# # Authentication check
+# if "authenticated" not in st.session_state or not st.session_state["authenticated"]:
+#     st.error("Access denied. Please go back to the main page and enter the passcode.")
+#     st.stop()
+
+# Initialize Firebase
+if not firebase_admin._apps:
+    cred = credentials.Certificate("coco-evaluation-firebase-adminsdk-p3m64-99c4ea22c1.json")
+    firebase_admin.initialize_app(cred)
+db = firestore.client()
+
+endpoint = os.environ["ENDPOINT_URL"]
+deployment = os.environ["DEPLOYMENT"]
+subscription_key = os.environ["subscription_key"]
+
+# OpenAI API setup
+client = AzureOpenAI(
+    azure_endpoint=endpoint,
+    api_key=subscription_key,
+    api_version=os.environ["api_version"]
+)
+
+def authenticate():
+    creds_dict = {
+        "type": os.environ.get("FIREBASE_TYPE", "service_account"),
+        "project_id": os.environ.get("FIREBASE_PROJECT_ID"),
+        "private_key_id": os.environ.get("FIREBASE_PRIVATE_KEY_ID"),
+        "private_key": os.environ.get("FIREBASE_PRIVATE_KEY", "").replace("\\n", "\n"),
+        "client_email": os.environ.get("FIREBASE_CLIENT_EMAIL"),
+        "client_id": os.environ.get("FIREBASE_CLIENT_ID"),
+        "auth_uri": os.environ.get("FIREBASE_AUTH_URI", "https://accounts.google.com/o/oauth2/auth"),
+        "token_uri": os.environ.get("FIREBASE_TOKEN_URI", "https://oauth2.googleapis.com/token"),
+        "auth_provider_x509_cert_url": os.environ.get("FIREBASE_AUTH_PROVIDER_X509_CERT_URL", 
+                                                    "https://www.googleapis.com/oauth2/v1/certs"),
+        "client_x509_cert_url": os.environ.get("FIREBASE_CLIENT_X509_CERT_URL"),
+        "universe_domain": "googleapis.com"
+
+    }
+    # Create a temporary JSON file
+    with tempfile.NamedTemporaryFile(suffix='.json', delete=False, mode='w') as temp_file:
+        json.dump(creds_dict, temp_file)
+        temp_file.close()
+
+    import uuid
+    
+    random_id = uuid.uuid4()
+    random_id_string = str(random_id)
+    evaluator_id = random_id_string
+    db = firestore.client()
+    db.collection("evaluator_ids").document(evaluator_id).set({
+        "evaluator_id": evaluator_id,
+        "timestamp": firestore.SERVER_TIMESTAMP
+    })
+
+    # Update session state
+    st.session_state["authenticated"] = True
+    st.session_state["evaluator_id"] = evaluator_id
+
+def init():
+    """Initialize all necessary components and state variables"""
+    # Initialize Firebase if not already initialized
+    if not firebase_admin._apps:
+        cred = credentials.Certificate("coco-evaluation-firebase-adminsdk-p3m64-99c4ea22c1.json")
+        firebase_admin.initialize_app(cred)
+    
+    # Initialize session state variables
+    if "messages" not in st.session_state:
+        st.session_state.messages = {}
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = str(uuid.uuid4())
+    if "chat_active" not in st.session_state:
+        st.session_state.chat_active = False
+    if "user_input" not in st.session_state:
+        st.session_state.user_input = ""
+    if "user_id" not in st.session_state:
+        st.session_state.user_id = f"anonymous_{str(uuid.uuid4())}"
+    if "selected_model" not in st.session_state:
+        st.session_state.selected_model = list(MODEL_CONFIGS.keys())[0]
+    if "model_profile" not in st.session_state:
+        st.session_state.model_profile = [0, 0]
+    
+    # Load vectorstore at startup
+    if "vectorstore" not in st.session_state:
+        with st.spinner("Loading document embeddings..."):
+            st.session_state.vectorstore = load_or_create_vectorstore()
+
+def get_classification(client, deployment, user_input):
+    """Classify the input as emotional (1) or informational (0)"""
+    chat_prompt = [
+        {"role": "system", "content": CLASSIFICATION_PROMPT},
+        {"role": "user", "content": user_input}
+    ]
+
+    completion = client.chat.completions.create(
+        model=deployment,
+        messages=chat_prompt,
+        max_tokens=1,
+        temperature=0,
+        top_p=0.9,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+    
+    return completion.choices[0].message.content.strip()
+def process_input():
+    try:
+        current_model = st.session_state.selected_model
+        user_input = st.session_state.user_input
+        
+        if not user_input.strip():
+            st.warning("Please enter a message before sending.")
+            return
+            
+        model_config = MODEL_CONFIGS.get(current_model)
+        if not model_config:
+            st.error("Invalid model selected. Please choose a valid model.")
+            return
+
+        if current_model not in st.session_state.messages:
+            st.session_state.messages[current_model] = []
+
+        st.session_state.messages[current_model].append({"role": "user", "content": user_input})
+        
+        try:
+            log_message("user", user_input)
+        except Exception as e:
+            st.warning(f"Failed to log message: {str(e)}")
+            
+        conversation_history = "\n".join([f"{msg['role'].capitalize()}: {msg['content']}" 
+                                        for msg in st.session_state.messages[current_model]])
+
+        # Helper function for error handling in API calls
+        def safe_api_call(messages, max_retries=3):
+            for attempt in range(max_retries):
+                try:
+                    response = client.chat.completions.create(
+                        model=deployment,
+                        messages=messages,
+                        max_tokens=3500,
+                        temperature=0.1,
+                        top_p=0.9
+                    )
+                    return response.choices[0].message.content.strip()
+                except Exception as e:
+                    if attempt == max_retries - 1:
+                        raise Exception(f"Failed to get response after {max_retries} attempts: {str(e)}")
+                    st.warning(f"Attempt {attempt + 1} failed, retrying...")
+                    time.sleep(1)
+
+        def perform_rag_query(input_text, conversation_history):
+            try:
+                relevant_docs = retrieve_relevant_documents(
+                    st.session_state.vectorstore, 
+                    input_text, 
+                    conversation_history,
+                    client=client
+                )
+                
+                model_messages = [
+                    {"role": "system", "content": f"{model_config['prompt']}\n\nContexto: {relevant_docs}"}
+                ] + st.session_state.messages[current_model]
+                
+                return safe_api_call(model_messages), relevant_docs
+                
+            except Exception as e:
+                st.error(f"Error in RAG query: {str(e)}")
+                return "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente.", ""
+
+        initial_response = None
+        initial_docs = ""
+
+        # Handle 2-stage model
+        if model_config.get('uses_classification', False):
+            try:
+                classification = get_classification(client, deployment, user_input)
+                
+                if 'classifications' not in st.session_state:
+                    st.session_state.classifications = {}
+                st.session_state.classifications[len(st.session_state.messages[current_model]) - 1] = classification
+
+                if classification == "0":
+                    initial_response, initial_docs = perform_rag_query(user_input, conversation_history)
+                else:
+                    model_messages = [
+                        {"role": "system", "content": PERSONA_PREFIX + EMOTIONAL_PROMPT}
+                    ] + st.session_state.messages[current_model]
+                    initial_response = safe_api_call(model_messages)
+                    
+            except Exception as e:
+                st.error(f"Error in classification stage: {str(e)}")
+                initial_response = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+
+        # Handle RAG models
+        if model_config.get('uses_rag', False):
+            try:
+                if not initial_response:
+                    initial_response, initial_docs = perform_rag_query(user_input, conversation_history)
+
+                verification_docs = retrieve_relevant_documents(
+                    st.session_state.vectorstore, 
+                    initial_response,
+                    conversation_history,
+                    client=client
+                )
+
+                combined_docs = initial_docs + "\nContexto de verificación adicional:\n" + verification_docs
+
+                verification_messages = [
+                    {
+                        "role": "system", 
+                        "content": f"Pregunta del paciente:{user_input} \nContexto: {combined_docs} \nRespuesta anterior: {initial_response}\n Verifique la precisión médica de la respuesta anterior y refine la respuesta según el contexto adicional."
+                    }
+                ]
+
+                assistant_reply = safe_api_call(verification_messages)
+                
+            except Exception as e:
+                st.error(f"Error in RAG processing: {str(e)}")
+                assistant_reply = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+        else:
+            try:
+                model_messages = [
+                    {"role": "system", "content": model_config['prompt']}
+                ] + st.session_state.messages[current_model]
+                
+                assistant_reply = safe_api_call(model_messages)
+                
+            except Exception as e:
+                st.error(f"Error generating response: {str(e)}")
+                assistant_reply = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+
+        # Store and log the final response
+        try:
+            st.session_state.messages[current_model].append({"role": "assistant", "content": assistant_reply})
+            log_message("assistant", assistant_reply)
+            # store_conversation_data()
+        except Exception as e:
+            st.warning(f"Failed to store or log response: {str(e)}")
+
+        st.session_state.user_input = ""
+        
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)}")
+        st.session_state.user_input = ""
+
+
+def check_document_relevance(query, doc, client):
+    """
+    Check document relevance using few-shot prompting for Spanish TB context.
+    
+    Args:
+        query (str): The user's input query
+        doc (str): The retrieved document text
+        client: The OpenAI client instance
+    
+    Returns:
+        bool: True if document is relevant, False otherwise
+    """
+    few_shot_prompt = f"""Determine si el documento es relevante para la consulta sobre tuberculosis.
+        Responde únicamente 'sí' si es relevante o 'no' si no es relevante.
+        Ejemplos:
+        Consulta: ¿Cuáles son los efectos secundarios de la rifampicina?
+        Documento: La rifampicina puede causar efectos secundarios como náuseas, vómitos y coloración naranja de fluidos corporales. Es importante tomar el medicamento con el estómago vacío.
+        Respuesta: sí
+        Consulta: ¿Cuánto dura el tratamiento de TB?
+        Documento: El dengue es una enfermedad viral transmitida por mosquitos. Los síntomas incluyen fiebre alta y dolor muscular.
+        Respuesta: no
+        Consulta: ¿Cómo se realiza la prueba de esputo?
+        Documento: Para la prueba de esputo, el paciente debe toser profundamente para obtener una muestra de las vías respiratorias. La muestra debe recogerse en ayunas.
+        Respuesta: sí
+        Consulta: ¿Qué medidas de prevención debo tomar en casa?
+        Documento: Mayo Clinic tiene una gran cantidad de pacientes que atender.
+        Respuesta: no
+        Consulta: {query}
+        Documento: {doc}
+        Respuesta:"""
+    
+    response = client.chat.completions.create(
+        model=deployment,
+        messages=[{"role": "user", "content": few_shot_prompt}],
+        max_tokens=3,
+        temperature=0.1,
+        top_p=0.9
+    )
+    
+    return response.choices[0].message.content.strip().lower() == "sí"
+
+# In retrieve_relevant_documents function
+def retrieve_relevant_documents(vectorstore, query, conversation_history, client, top_k=3, score_threshold=0.5):
+    if not vectorstore:
+        st.error("Vector store not initialized")
+        return ""
+        
+    try:
+        recent_history = "\n".join(conversation_history.split("\n")[-3:]) if conversation_history else ""
+        full_query = query
+        if len(recent_history) < 200:
+            full_query = f"{recent_history} {query}".strip()
+        
+        results = vectorstore.similarity_search_with_score(
+            full_query,
+            k=top_k,
+            distance_metric="cos"
+        )
+        
+        if not results:
+            return "No se encontraron documentos relevantes."
+        
+        # Handle case where results don't include scores
+        if results and not isinstance(results[0], tuple):
+            # If results are just documents without scores, assign a default score
+            score_filtered_results = [(doc, 1.0) for doc in results]
+        else:
+            # Filter by similarity score
+            score_filtered_results = [
+                (result, score) for result, score in results 
+                if score > score_threshold
+            ]
+        
+        # Apply relevance checking to remaining documents
+        relevant_results = []
+        for result, score in score_filtered_results:
+            if check_document_relevance(query, result.page_content, client):
+                relevant_results.append((result, score))
+        
+        # Fallback to default context if no relevant docs found
+        if not relevant_results:
+            if score_filtered_results:
+                print("No relevant documents found after relevance check.")
+                return "Eres un modelo de IA centrado en la tuberculosis."
+            return ""
+        
+        # Format results
+        combined_results = [
+            f"Document excerpt (score: {score:.2f}):\n{result.page_content}"
+            for result, score in relevant_results
+        ]
+        
+        return "\n\n".join(combined_results)
+        
+    except Exception as e:
+        st.error(f"Error retrieving documents: {str(e)}")
+        return "Error al buscar documentos relevantes."
+
+def store_conversation_data():
+    current_model = st.session_state.selected_model
+    model_config = MODEL_CONFIGS[current_model]
+    
+    doc_ref = db.collection('conversations').document(str(st.session_state.session_id))
+    doc_ref.set({
+        'timestamp': firestore.SERVER_TIMESTAMP,
+        'userID': st.session_state.user_id,
+        'model_index': list(MODEL_CONFIGS.keys()).index(current_model) + 1,
+        'profile_index': st.session_state.model_profile[1],
+        'profile': '',
+        'conversation': st.session_state.messages[current_model],
+        'uses_rag': model_config['uses_rag']
+    })
+
+def log_message(role, content):
+    current_model = st.session_state.selected_model
+    model_config = MODEL_CONFIGS[current_model]
+    collection_name = f"messages_model_{list(MODEL_CONFIGS.keys()).index(current_model) + 1}"
+    
+    doc_ref = db.collection(collection_name).document()
+    doc_ref.set({
+        'timestamp': firestore.SERVER_TIMESTAMP,
+        'session_id': str(st.session_state.session_id),
+        'userID': st.session_state.get('user_id', 'anonymous'),
+        'role': role,
+        'content': content,
+        'model_name': model_config['name']
+    })
+
+def reset_conversation():
+    current_model = st.session_state.selected_model
+    
+    if current_model in st.session_state.messages and st.session_state.messages[current_model]:
+        doc_ref = db.collection('conversation_ends').document()
+        doc_ref.set({
+            'timestamp': firestore.SERVER_TIMESTAMP,
+            'session_id': str(st.session_state.session_id),
+            'userID': st.session_state.get('user_id', 'anonymous'),
+            'total_messages': len(st.session_state.messages[current_model]),
+            'model_name': MODEL_CONFIGS[current_model]['name']
+        })
+    
+    st.session_state.messages[current_model] = []
+    st.session_state.session_id = str(uuid.uuid4())
+    st.session_state.chat_active = False
+    st.query_params.clear()
+
+class ModelEvaluationSystem:
+    def __init__(self, db: firestore.Client):
+        self.db = db
+        self.models_to_evaluate = list(MODEL_CONFIGS.keys())  # Use existing MODEL_CONFIGS
+        self._initialize_state()
+        self._load_existing_evaluations()
+
+    def _initialize_state(self):
+        """Initialize or load evaluation state."""
+        if "evaluation_state" not in st.session_state:
+            st.session_state.evaluation_state = {}
+
+        if "evaluated_models" not in st.session_state:
+            st.session_state.evaluated_models = {}
+
+    def _get_current_user_id(self):
+        """
+        Get current user identifier.
+        """
+        return st.session_state["evaluator_id"]
+
+    def render_evaluation_progress(self):
+        """
+        Render evaluation progress in the sidebar.
+        """
+        st.sidebar.header("Evaluation Progress")
+        
+        # Calculate progress
+        total_models = len(self.models_to_evaluate)
+        evaluated_models = len(st.session_state.evaluated_models)
+        
+        # Progress bar
+        st.sidebar.progress(evaluated_models / total_models)
+        
+        # List of models and their status
+        for model in self.models_to_evaluate:
+            status = "✅ Completed" if st.session_state.evaluated_models.get(model, False) else "⏳ Pending"
+            st.sidebar.markdown(f"{model}: {status}")
+        
+        # Check if all models are evaluated
+        if evaluated_models == total_models:
+            self._render_completion_screen()
+
+    def _load_existing_evaluations(self):
+        """
+        Load existing evaluations from Firestore for the current user/session.
+        """
+        try:
+            user_id = self._get_current_user_id()
+            
+            existing_evals = self.db.collection('model_evaluations').document(user_id).get()
+            
+            if existing_evals.exists:
+                loaded_data = existing_evals.to_dict()
+                
+                # Populate evaluated models from existing data
+                for model, eval_data in loaded_data.get('evaluations', {}).items():
+                    if eval_data.get('status') == 'complete':
+                        st.session_state.evaluated_models[model] = True
+                    
+                    # Restore slider and text area values
+                    st.session_state[f"performance_slider_{model}"] = eval_data.get('overall_score', 5)
+                    
+                    for dimension, dim_data in eval_data.get('dimension_evaluations', {}).items():
+                        dim_key = dimension.lower().replace(' ', '_')
+                        st.session_state[f"{dim_key}_score_{model}"] = dim_data.get('score', 5)
+                        
+                        if dim_data.get('follow_up_reason'):
+                            st.session_state[f"follow_up_reason_{dim_key}_{model}"] = dim_data['follow_up_reason']
+        
+        except Exception as e:
+            st.error(f"Error loading existing evaluations: {e}")
+
+    def render_evaluation_sidebar(self, selected_model):
+        """
+        Render evaluation sidebar for the selected model, including the Empathy section.
+        """
+        # Evaluation dimensions based on the QUEST framework
+        dimensions = {
+            "Accuracy": "The answers provided by the chatbot were medically accurate and contained no errors",
+            "Comprehensiveness": "The answers are comprehensive and are not missing important information",
+            "Helpfulness to the Human Responder": "The answers are helpful to the human responder and require minimal or no edits before sending them to the patient",
+            "Understanding": "The chatbot was able to understand my questions and responded appropriately to the questions asked",
+            "Clarity": "The chatbot was able to provide answers that patients would be able to understand for their level of medical literacy",
+            "Language": "The chatbot provided answers that were idiomatically appropriate and are indistinguishable from those produced by native Spanish speakers",
+            "Harm": "The answers provided do not contain information that would lead to patient harm or negative outcomes",
+            "Fabrication": "The chatbot provided answers that were free of hallucinations, fabricated information, or other information that was not based or evidence-based medical practice",
+            "Trust": "The chatbot provided responses that are similar to those that would be provided by an expert or healthcare professional with experience in treating tuberculosis"
+        }
+
+        empathy_statements = [
+            "Response included expression of emotions, such as warmth, compassion, and concern or similar towards the patient (i.e. Todo estará bien. / Everything will be fine).",
+            "Response communicated an understanding of feelings and experiences interpreted from the patient's responses (i.e. Entiendo su preocupación. / I understand your concern).",
+            "Response aimed to improve understanding by exploring the feelings and experiences of the patient (i.e. Cuénteme más de cómo se está sintiendo. / Tell me more about how you are feeling.)"
+        ]
+
+        st.sidebar.subheader(f"Evaluate {selected_model}")
+
+        # Overall model performance evaluation
+        overall_score = st.sidebar.slider(
+            "Overall Model Performance", 
+            min_value=1, 
+            max_value=10, 
+            value=st.session_state.get(f"performance_slider_{selected_model}", 5), 
+            key=f"performance_slider_{selected_model}",
+            on_change=self._track_evaluation_change,
+            args=(selected_model, 'overall_score')
+        )
+
+        # Dimension evaluations
+        dimension_evaluations = {}
+        all_questions_answered = True
+
+        for dimension in dimensions.keys():
+            st.sidebar.markdown(f"**{dimension} Evaluation**")
+
+            # Define the Likert scale options
+            likert_options = {
+                "Strongly Disagree": 1,
+                "Disagree": 2,
+                "Neutral": 3,
+                "Agree": 4,
+                "Strongly Agree": 5
+            }
+
+            # Get the current value and convert it to the corresponding text option
+            current_value = st.session_state.get(f"{dimension.lower().replace(' ', '_')}_score_{selected_model}", 3)
+            current_text = [k for k, v in likert_options.items() if v == current_value][0]
+
+            # Create the selectbox for rating
+            dimension_text_score = st.sidebar.selectbox(
+                f"{dimensions[dimension]} Rating",
+                options=list(likert_options.keys()),
+                index=list(likert_options.keys()).index(current_text),
+                key=f"{dimension.lower().replace(' ', '_')}_score_text_{selected_model}",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, dimension)
+            )
+
+            # Convert text score back to numeric value for storage
+            dimension_score = likert_options[dimension_text_score]
+
+            # Conditional follow-up for disagreement scores
+            if dimension_score < 4:
+                follow_up_question = "Please, provide an example or description for your feedback."
+                feedback_type = "disagreement"
+
+                follow_up_reason = st.sidebar.text_area(
+                    follow_up_question, 
+                    value=st.session_state.get(f"follow_up_reason_{dimension.lower().replace(' ', '_')}_{selected_model}", ""),
+                    key=f"follow_up_reason_{dimension.lower().replace(' ', '_')}_{selected_model}",
+                    help=f"Please provide specific feedback about the model's performance in {dimension}",
+                    on_change=self._track_evaluation_change,
+                    args=(selected_model, f"{dimension}_feedback")
+                )
+
+                # Check if the follow-up question was answered
+                if not follow_up_reason:
+                    all_questions_answered = False
+
+                dimension_evaluations[dimension] = {
+                    "score": dimension_score,
+                    "feedback_type": feedback_type,
+                    "follow_up_reason": follow_up_reason
+                }
+            else:
+                dimension_evaluations[dimension] = {
+                    "score": dimension_score,
+                    "feedback_type": "neutral_or_positive",
+                    "follow_up_reason": None
+                }
+
+        st.sidebar.markdown(f"**Empathy Section**")
+        st.sidebar.markdown("<small><a href='https://docs.google.com/document/d/1Olqfo14Zde_GXXWAPzG0OiYUE53nc_I3/edit?usp=sharing&ouid=107404473110455439345&rtpof=true&sd=true' target='_blank'>Look here for example ratings</a></small>", unsafe_allow_html=True)
+
+        # Empathy section with updated scale
+        empathy_evaluations = {}
+        empathy_likert_options = {
+            "No expression of an empathetic response": 1,
+            "Expressed empathetic response to a weak degree": 2,
+            "Expressed empathetic response strongly": 3
+        }
+
+        for i, _ in enumerate(empathy_statements, 1):
+            st.sidebar.markdown(f"**Empathy Evaluation {i}:**")
+
+            # Get current value and convert to text
+            current_value = st.session_state.get(f"empathy_score_{i}_{selected_model}", 1)
+            current_text = [k for k, v in empathy_likert_options.items() if v == current_value][0]
+
+            empathy_text_score = st.sidebar.selectbox(
+                f"How strongly do you agree with the following statement for empathy: {empathy_statements[i-1]}?",
+                options=list(empathy_likert_options.keys()),
+                index=list(empathy_likert_options.keys()).index(current_text),
+                key=f"empathy_score_text_{i}_{selected_model}",
+                help=f"Please rate how empathetic the response was based on statement.",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, f"empathy_score_{i}")
+            )
+
+            # Convert text score back to numeric value
+            empathy_score = empathy_likert_options[empathy_text_score]
+
+            follow_up_question = f"Please provide a brief rationale for your rating:"
+            follow_up_reason = st.sidebar.text_area(
+                follow_up_question, 
+                value=st.session_state.get(f"follow_up_reason_empathy_{i}_{selected_model}", ""),
+                key=f"follow_up_reason_empathy_{i}_{selected_model}",
+                help="Please explain why you gave this rating.",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, f"empathy_{i}_feedback")
+            )
+
+            # Check if the follow-up question was answered
+            if not follow_up_reason:
+                all_questions_answered = False
+
+            empathy_evaluations[f"statement_{i}"] = {
+                "score": empathy_score,
+                "follow_up_reason": follow_up_reason
+            }
+
+        # Add extra feedback section
+        st.sidebar.markdown("**Additional Feedback**")
+        extra_feedback = st.sidebar.text_area(
+            "Extra feedback, e.g. whether it is similar or too different with some other model",
+            value=st.session_state.get(f"extra_feedback_{selected_model}", ""),
+            key=f"extra_feedback_{selected_model}",
+            help="Please provide any additional comments or comparisons with other models.",
+            on_change=self._track_evaluation_change,
+            args=(selected_model, "extra_feedback")
+        )
+
+        # Submit evaluation button
+        submit_disabled = not all_questions_answered
+
+        submit_button = st.sidebar.button(
+            "Submit Evaluation", 
+            key=f"submit_evaluation_{selected_model}",
+            disabled=submit_disabled
+        )
+
+        if submit_button:
+            # Prepare comprehensive evaluation data
+            evaluation_data = {
+                "model": selected_model,
+                "overall_score": overall_score,
+                "dimension_evaluations": dimension_evaluations,
+                "empathy_evaluations": empathy_evaluations,
+                "extra_feedback": extra_feedback,
+                "status": "complete"
+            }
+
+            self.save_model_evaluation(evaluation_data)
+
+            # Mark model as evaluated
+            st.session_state.evaluated_models[selected_model] = True
+
+            st.sidebar.success("Evaluation submitted successfully!")
+
+            # Render progress to check for completion
+            self.render_evaluation_progress()
+
+
+    def _track_evaluation_change(self, model: str, change_type: str):
+        """
+        Track changes in evaluation fields in real-time.
+        """
+        try:
+            # Prepare evaluation data
+            evaluation_data = {
+                "model": model,
+                "overall_score": st.session_state.get(f"performance_slider_{model}", 5),
+                "dimension_evaluations": {},
+                "status": "in_progress"
+            }
+            
+            # Dimensions to check
+            dimensions = [
+                "Accuracy",
+                "Coherence", 
+                "Relevance", 
+                "Creativity", 
+                "Ethical Considerations"
+            ]
+            
+            # Populate dimension evaluations
+            for dimension in dimensions:
+                dim_key = dimension.lower().replace(' ', '_')
+                evaluation_data["dimension_evaluations"][dimension] = {
+                    "score": st.session_state.get(f"{dim_key}_score_{model}", 5),
+                    "follow_up_reason": st.session_state.get(f"follow_up_reason_{dim_key}_{model}", "")
+                }
+            
+            # Save partial evaluation
+            self.save_model_evaluation(evaluation_data)
+        
+        except Exception as e:
+            st.error(f"Error tracking evaluation change: {e}")
+
+    def save_model_evaluation(self, evaluation_data: Dict[str, Any]):
+        """
+        Save the model evaluation data to the database.
+        """
+        try:
+            # Get current user ID (replace with actual method)
+            user_id = self._get_current_user_id()
+            
+            # Create or update document in Firestore
+            user_eval_ref = self.db.collection('model_evaluations').document(user_id)
+            
+            # Update or merge the evaluation for this specific model
+            user_eval_ref.set({
+                'evaluations': {
+                    evaluation_data['model']: evaluation_data
+                }
+            }, merge=True)
+            
+            st.toast(f"Evaluation for {evaluation_data['model']} saved {'completely' if evaluation_data.get('status') == 'complete' else 'partially'}")
+        
+        except Exception as e:
+            st.error(f"Error saving evaluation: {e}")
+
+    def _render_completion_screen(self):
+        """
+        Render a completion screen when all models are evaluated.
+        """
+        # Clear the main content area
+        st.empty()
+        
+        # Display completion message
+        st.balloons()
+        st.title("🎉 Evaluation Complete!")
+        st.markdown("Thank you for your valuable feedback.")
+        
+        # Reward link (replace with actual reward link)
+        st.markdown("### Claim Your Reward")
+        st.markdown("""
+        Click the button below to receive your reward:
+        
+        [🎁 Claim Reward](https://example.com/reward)
+        """)
+        
+        # Optional: Log completion event
+        self._log_evaluation_completion()
+
+    def _log_evaluation_completion(self):
+        """
+        Log the completion of all model evaluations.
+        """
+        try:
+            user_id = self._get_current_user_id()
+            
+            # Log completion timestamp
+            completion_log_ref = self.db.collection('evaluation_completions').document(user_id)
+            completion_log_ref.set({
+                'completed_at': firestore.SERVER_TIMESTAMP,
+                'models_evaluated': list(self.models_to_evaluate)
+            })
+        
+        except Exception as e:
+            st.error(f"Error logging evaluation completion: {e}")
+
+def main():
+    try:
+        authenticate()
+        init()
+        
+        # Initialize evaluation system
+        # evaluation_system = ModelEvaluationSystem(db)
+        
+        st.title("Chat with AI Models")
+        # Sidebar configuration
+        with st.sidebar:
+            st.header("Settings")
+    
+            # Function to call reset_conversation when the model selection changes
+            def on_model_change():
+                try:
+                    reset_conversation()
+                except Exception as e:
+                    st.error(f"Error resetting conversation: {str(e)}")
+    
+            selected_model = st.selectbox(
+                "Select Model",
+                options=list(MODEL_CONFIGS.keys()),
+                key="model_selector",
+                on_change=on_model_change
+            )
+            
+            if selected_model not in MODEL_CONFIGS:
+                st.error("Invalid model selected")
+                return
+                
+            st.session_state.selected_model = selected_model
+    
+            if st.button("Reset Conversation", key="reset_button"):
+                try:
+                    reset_conversation()
+                except Exception as e:
+                    st.error(f"Error resetting conversation: {str(e)}")
+    
+            # Add evaluation sidebar
+            # evaluation_system.render_evaluation_sidebar(selected_model)
+    
+            with st.expander("Instructions"):
+                st.write("""
+                **How to Use the Chatbot Interface:**
+                1. **Choose the assigned model**: Choose the model to chat with that was assigned in the Qualtrics.
+                2. **Chat with GPT-4**: Enter your messages in the input box to chat with the assistant.
+                3. **Reset Conversation**: Click "Reset Conversation" to clear chat history and start over.
+                """)
+        
+        chat_container = st.container()
+        
+        with chat_container:
+            if not st.session_state.chat_active:
+                st.session_state.chat_active = True
+            
+            if selected_model in st.session_state.messages:
+                message_pairs = []
+                # Group messages into pairs (user + assistant)
+                for i in range(0, len(st.session_state.messages[selected_model]), 2):
+                    if i + 1 < len(st.session_state.messages[selected_model]):
+                        message_pairs.append((
+                            st.session_state.messages[selected_model][i],
+                            st.session_state.messages[selected_model][i + 1]
+                        ))
+                    else:
+                        message_pairs.append((
+                            st.session_state.messages[selected_model][i],
+                            None
+                        ))
+                
+                # Display message pairs with turn numbers
+                for turn_num, (user_msg, assistant_msg) in enumerate(message_pairs, 1):
+                    # Display user message
+                    col1, col2 = st.columns([0.9, 0.1])
+                    with col1:
+                        with st.chat_message(user_msg["role"]):
+                            st.write(user_msg["content"])
+                            # Show classification for Model 3
+                            if (selected_model == "Model 3" and 
+                                'classifications' in st.session_state):
+                                idx = (turn_num - 1) * 2
+                                if idx in st.session_state.classifications:
+                                    classification = "Emotional" if st.session_state.classifications[idx] == "1" else "Informational"
+                                    st.caption(f"Message classified as: {classification}")
+                    with col2:
+                        st.write(f"{turn_num}")
+                    
+                    # Display assistant message if it exists
+                    if assistant_msg:
+                        with st.chat_message(assistant_msg["role"]):
+                            st.write(assistant_msg["content"])
+            
+            st.text_input(
+                "Type your message here...",
+                key="user_input",
+                value="",
+                on_change=process_input
+            )
+    except Exception as e:
+        st.error(f"An unexpected error occurred in the main application: {str(e)}")
+
+if __name__ == "__main__":
+    main()

pages/_2S_Model.py

@@ -0,0 +1,942 @@
+import uuid
+import streamlit as st
+from openai import AzureOpenAI
+import firebase_admin
+from firebase_admin import credentials, firestore
+from typing import Dict, Any
+import time
+import os
+import tempfile
+import json
+
+from utils.prompt_utils import PERSONA_PREFIX, baseline, baseline_esp, fs, RAG, EMOTIONAL_PROMPT, CLASSIFICATION_PROMPT, INFORMATIONAL_PROMPT
+from utils.RAG_utils import load_or_create_vectorstore
+
+# PERSONA_PREFIX = ""
+# baseline = ""
+# baseline_esp = ""
+# fs = ""
+# RAG = ""
+# EMOTIONAL_PROMPT = ""
+# CLASSIFICATION_PROMPT = """
+# Determine si esta afirmación busca empatía o (1) o busca información (0).
+# Clasifique como emocional sólo si la pregunta expresa preocupación, ansiedad o malestar sobre el estado de salud del paciente.
+# En caso contrario, clasificar como informativo.
+
+# Ejemplos:
+# - Pregunta: Me siento muy ansioso por mi diagnóstico de tuberculosis. 1
+# - Pregunta: ¿Cuáles son los efectos secundarios comunes de los medicamentos contra la tuberculosis? 0
+# - Pregunta: Estoy preocupada porque tengo mucho dolor. 1
+# - Pregunta: ¿Es seguro tomar medicamentos como analgésicos junto con medicamentos para la tuberculosis? 0
+
+# Aquí está la declaración para clasificar. Simplemente responda con el número "1" o "0":
+# """
+
+# INFORMATIONAL_PROMPT = ""
+
+# Model configurations remain the same
+MODEL_CONFIGS = {
+    # "Model 0: Naive English Baseline Model": {
+    #     "name": "Model 0: Naive English Baseline Model",
+    #     "prompt": PERSONA_PREFIX + baseline,
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 1: Naive Spanish Baseline Model": {
+    #     "name": "Model 1: Baseline Model",
+    #     "prompt": PERSONA_PREFIX + baseline_esp,
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 1": {
+    #     "name": "Model 1: Few_Shot model",
+    #     "prompt": PERSONA_PREFIX + fs,
+    #     "uses_rag": False,
+    #     "uses_classification": False
+    # },
+    # "Model 3: RAG Model": {F
+    #     "name": "Model 3: RAG Model",
+    #     "prompt": PERSONA_PREFIX + RAG,
+    #     "uses_rag": True,
+    #     "uses_classification": False
+    # },
+    # "Model 2": {
+    #     "name": "Model 2: RAG + Few_Shot Model",
+    #     "prompt": PERSONA_PREFIX + RAG + fs,
+    #     "uses_rag": True,
+    #     "uses_classification": False
+    # },
+    "Model 3": {
+        "name": "Model 3: 2-Stage Classification Model",
+        "prompt": PERSONA_PREFIX + INFORMATIONAL_PROMPT,  # default
+        "uses_rag": False,
+        "uses_classification": False
+    },
+    # "Model 6: Multi-Agent": {
+    #     "name": "Model 6: Multi-Agent",
+    #     "prompt": PERSONA_PREFIX + INFORMATIONAL_PROMPT,  # default
+    #     "uses_rag": True,
+    #     "uses_classification": True,
+    #     "uses_judges": True
+    # }
+}
+PASSCODE = os.environ["MY_PASSCODE"]
+
+# # Authentication check
+# if "authenticated" not in st.session_state or not st.session_state["authenticated"]:
+#     st.error("Access denied. Please go back to the main page and enter the passcode.")
+#     st.stop()
+
+# Initialize Firebase
+if not firebase_admin._apps:
+    cred = credentials.Certificate("coco-evaluation-firebase-adminsdk-p3m64-99c4ea22c1.json")
+    firebase_admin.initialize_app(cred)
+db = firestore.client()
+
+endpoint = os.environ["ENDPOINT_URL"]
+deployment = os.environ["DEPLOYMENT"]
+subscription_key = os.environ["subscription_key"]
+
+# OpenAI API setup
+client = AzureOpenAI(
+    azure_endpoint=endpoint,
+    api_key=subscription_key,
+    api_version=os.environ["api_version"]
+)
+
+def authenticate():
+    creds_dict = {
+        "type": os.environ.get("FIREBASE_TYPE", "service_account"),
+        "project_id": os.environ.get("FIREBASE_PROJECT_ID"),
+        "private_key_id": os.environ.get("FIREBASE_PRIVATE_KEY_ID"),
+        "private_key": os.environ.get("FIREBASE_PRIVATE_KEY", "").replace("\\n", "\n"),
+        "client_email": os.environ.get("FIREBASE_CLIENT_EMAIL"),
+        "client_id": os.environ.get("FIREBASE_CLIENT_ID"),
+        "auth_uri": os.environ.get("FIREBASE_AUTH_URI", "https://accounts.google.com/o/oauth2/auth"),
+        "token_uri": os.environ.get("FIREBASE_TOKEN_URI", "https://oauth2.googleapis.com/token"),
+        "auth_provider_x509_cert_url": os.environ.get("FIREBASE_AUTH_PROVIDER_X509_CERT_URL", 
+                                                    "https://www.googleapis.com/oauth2/v1/certs"),
+        "client_x509_cert_url": os.environ.get("FIREBASE_CLIENT_X509_CERT_URL"),
+        "universe_domain": "googleapis.com"
+
+    }
+    # Create a temporary JSON file
+    with tempfile.NamedTemporaryFile(suffix='.json', delete=False, mode='w') as temp_file:
+        json.dump(creds_dict, temp_file)
+        temp_file.close()
+
+    import uuid
+
+    
+    random_id = uuid.uuid4()
+    random_id_string = str(random_id)
+    evaluator_id = random_id_string
+    db = firestore.client()
+    db.collection("evaluator_ids").document(evaluator_id).set({
+        "evaluator_id": evaluator_id,
+        "timestamp": firestore.SERVER_TIMESTAMP
+    })
+
+    # Update session state
+    st.session_state["authenticated"] = True
+    st.session_state["evaluator_id"] = evaluator_id
+
+
+def init():
+    """Initialize all necessary components and state variables"""
+    # Initialize session state variables
+    if "messages" not in st.session_state:
+        st.session_state.messages = {}
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = str(uuid.uuid4())
+    if "chat_active" not in st.session_state:
+        st.session_state.chat_active = False
+    if "user_input" not in st.session_state:
+        st.session_state.user_input = ""
+    if "user_id" not in st.session_state:
+        st.session_state.user_id = f"anonymous_{str(uuid.uuid4())}"
+    if "selected_model" not in st.session_state:
+        st.session_state.selected_model = list(MODEL_CONFIGS.keys())[0]
+    if "model_profile" not in st.session_state:
+        st.session_state.model_profile = [0, 0]
+    
+    # Load vectorstore at startup
+    if "vectorstore" not in st.session_state:
+        with st.spinner("Loading document embeddings..."):
+            st.session_state.vectorstore = load_or_create_vectorstore()
+
+def get_classification(client, deployment, user_input):
+    """Classify the input as emotional (1) or informational (0)"""
+    chat_prompt = [
+        {"role": "system", "content": CLASSIFICATION_PROMPT},
+        {"role": "user", "content": user_input}
+    ]
+
+    completion = client.chat.completions.create(
+        model=deployment,
+        messages=chat_prompt,
+        max_tokens=1,
+        temperature=0,
+        top_p=0.9,
+        frequency_penalty=0,
+        presence_penalty=0,
+        stop=None
+    )
+    
+    return completion.choices[0].message.content.strip()
+def process_input():
+    try:
+        current_model = st.session_state.selected_model
+        user_input = st.session_state.user_input
+        
+        if not user_input.strip():
+            st.warning("Please enter a message before sending.")
+            return
+            
+        model_config = MODEL_CONFIGS.get(current_model)
+        if not model_config:
+            st.error("Invalid model selected. Please choose a valid model.")
+            return
+
+        if current_model not in st.session_state.messages:
+            st.session_state.messages[current_model] = []
+
+        st.session_state.messages[current_model].append({"role": "user", "content": user_input})
+        
+        try:
+            log_message("user", user_input)
+        except Exception as e:
+            st.warning(f"Failed to log message: {str(e)}")
+            
+        conversation_history = "\n".join([f"{msg['role'].capitalize()}: {msg['content']}" 
+                                        for msg in st.session_state.messages[current_model]])
+
+        # Helper function for error handling in API calls
+        def safe_api_call(messages, max_retries=3):
+            for attempt in range(max_retries):
+                try:
+                    response = client.chat.completions.create(
+                        model=deployment,
+                        messages=messages,
+                        max_tokens=3500,
+                        temperature=0.1,
+                        top_p=0.9
+                    )
+                    return response.choices[0].message.content.strip()
+                except Exception as e:
+                    if attempt == max_retries - 1:
+                        raise Exception(f"Failed to get response after {max_retries} attempts: {str(e)}")
+                    st.warning(f"Attempt {attempt + 1} failed, retrying...")
+                    time.sleep(1)
+
+        def perform_rag_query(input_text, conversation_history):
+            try:
+                relevant_docs = retrieve_relevant_documents(
+                    st.session_state.vectorstore, 
+                    input_text, 
+                    conversation_history,
+                    client=client
+                )
+                
+                model_messages = [
+                    {"role": "system", "content": f"{model_config['prompt']}\n\nContexto: {relevant_docs}"}
+                ] + st.session_state.messages[current_model]
+                
+                return safe_api_call(model_messages), relevant_docs
+                
+            except Exception as e:
+                st.error(f"Error in RAG query: {str(e)}")
+                return "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente.", ""
+
+        initial_response = None
+        initial_docs = ""
+
+        # Handle 2-stage model
+        if model_config.get('uses_classification', False):
+            try:
+                classification = get_classification(client, deployment, user_input)
+                
+                if 'classifications' not in st.session_state:
+                    st.session_state.classifications = {}
+                st.session_state.classifications[len(st.session_state.messages[current_model]) - 1] = classification
+
+                if classification == "0":
+                    initial_response, initial_docs = perform_rag_query(user_input, conversation_history)
+                else:
+                    model_messages = [
+                        {"role": "system", "content": PERSONA_PREFIX + EMOTIONAL_PROMPT}
+                    ] + st.session_state.messages[current_model]
+                    initial_response = safe_api_call(model_messages)
+                    
+            except Exception as e:
+                st.error(f"Error in classification stage: {str(e)}")
+                initial_response = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+
+        # Handle RAG models
+        if model_config.get('uses_rag', False):
+            try:
+                if not initial_response:
+                    initial_response, initial_docs = perform_rag_query(user_input, conversation_history)
+
+                verification_docs = retrieve_relevant_documents(
+                    st.session_state.vectorstore, 
+                    initial_response,
+                    conversation_history,
+                    client=client
+                )
+
+                combined_docs = initial_docs + "\nContexto de verificación adicional:\n" + verification_docs
+
+                verification_messages = [
+                    {
+                        "role": "system", 
+                        "content": f"Pregunta del paciente:{user_input} \nContexto: {combined_docs} \nRespuesta anterior: {initial_response}\n Verifique la precisión médica de la respuesta anterior y refine la respuesta según el contexto adicional."
+                    }
+                ]
+
+                assistant_reply = safe_api_call(verification_messages)
+                
+            except Exception as e:
+                st.error(f"Error in RAG processing: {str(e)}")
+                assistant_reply = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+        else:
+            try:
+                model_messages = [
+                    {"role": "system", "content": model_config['prompt']}
+                ] + st.session_state.messages[current_model]
+                
+                assistant_reply = safe_api_call(model_messages)
+                
+            except Exception as e:
+                st.error(f"Error generating response: {str(e)}")
+                assistant_reply = "Lo siento, hubo un error al procesar tu consulta. Por favor, intenta nuevamente."
+
+        # Store and log the final response
+        try:
+            st.session_state.messages[current_model].append({"role": "assistant", "content": assistant_reply})
+            log_message("assistant", assistant_reply)
+            # store_conversation_data()
+        except Exception as e:
+            st.warning(f"Failed to store or log response: {str(e)}")
+
+        st.session_state.user_input = ""
+        
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)}")
+        st.session_state.user_input = ""
+
+
+def check_document_relevance(query, doc, client):
+    """
+    Check document relevance using few-shot prompting for Spanish TB context.
+    
+    Args:
+        query (str): The user's input query
+        doc (str): The retrieved document text
+        client: The OpenAI client instance
+    
+    Returns:
+        bool: True if document is relevant, False otherwise
+    """
+    few_shot_prompt = f"""Determine si el documento es relevante para la consulta sobre tuberculosis.
+        Responde únicamente 'sí' si es relevante o 'no' si no es relevante.
+        Ejemplos:
+        Consulta: ¿Cuáles son los efectos secundarios de la rifampicina?
+        Documento: La rifampicina puede causar efectos secundarios como náuseas, vómitos y coloración naranja de fluidos corporales. Es importante tomar el medicamento con el estómago vacío.
+        Respuesta: sí
+        Consulta: ¿Cuánto dura el tratamiento de TB?
+        Documento: El dengue es una enfermedad viral transmitida por mosquitos. Los síntomas incluyen fiebre alta y dolor muscular.
+        Respuesta: no
+        Consulta: ¿Cómo se realiza la prueba de esputo?
+        Documento: Para la prueba de esputo, el paciente debe toser profundamente para obtener una muestra de las vías respiratorias. La muestra debe recogerse en ayunas.
+        Respuesta: sí
+        Consulta: ¿Qué medidas de prevención debo tomar en casa?
+        Documento: Mayo Clinic tiene una gran cantidad de pacientes que atender.
+        Respuesta: no
+        Consulta: {query}
+        Documento: {doc}
+        Respuesta:"""
+    
+    response = client.chat.completions.create(
+        model=deployment,
+        messages=[{"role": "user", "content": few_shot_prompt}],
+        max_tokens=3,
+        temperature=0.1,
+        top_p=0.9
+    )
+    
+    return response.choices[0].message.content.strip().lower() == "sí"
+
+# In retrieve_relevant_documents function
+def retrieve_relevant_documents(vectorstore, query, conversation_history, client, top_k=3, score_threshold=0.5):
+    if not vectorstore:
+        st.error("Vector store not initialized")
+        return ""
+        
+    try:
+        recent_history = "\n".join(conversation_history.split("\n")[-3:]) if conversation_history else ""
+        full_query = query
+        if len(recent_history) < 200:
+            full_query = f"{recent_history} {query}".strip()
+        
+        results = vectorstore.similarity_search_with_score(
+            full_query,
+            k=top_k,
+            distance_metric="cos"
+        )
+        
+        if not results:
+            return "No se encontraron documentos relevantes."
+        
+        # Handle case where results don't include scores
+        if results and not isinstance(results[0], tuple):
+            # If results are just documents without scores, assign a default score
+            score_filtered_results = [(doc, 1.0) for doc in results]
+        else:
+            # Filter by similarity score
+            score_filtered_results = [
+                (result, score) for result, score in results 
+                if score > score_threshold
+            ]
+        
+        # Apply relevance checking to remaining documents
+        relevant_results = []
+        for result, score in score_filtered_results:
+            if check_document_relevance(query, result.page_content, client):
+                relevant_results.append((result, score))
+        
+        # Fallback to default context if no relevant docs found
+        if not relevant_results:
+            if score_filtered_results:
+                print("No relevant documents found after relevance check.")
+                return "Eres un modelo de IA centrado en la tuberculosis."
+            return ""
+        
+        # Format results
+        combined_results = [
+            f"Document excerpt (score: {score:.2f}):\n{result.page_content}"
+            for result, score in relevant_results
+        ]
+        
+        return "\n\n".join(combined_results)
+        
+    except Exception as e:
+        st.error(f"Error retrieving documents: {str(e)}")
+        return "Error al buscar documentos relevantes."
+
+def store_conversation_data():
+    current_model = st.session_state.selected_model
+    model_config = MODEL_CONFIGS[current_model]
+    
+    doc_ref = db.collection('conversations').document(str(st.session_state.session_id))
+    doc_ref.set({
+        'timestamp': firestore.SERVER_TIMESTAMP,
+        'userID': st.session_state.user_id,
+        'model_index': list(MODEL_CONFIGS.keys()).index(current_model) + 1,
+        'profile_index': st.session_state.model_profile[1],
+        'profile': '',
+        'conversation': st.session_state.messages[current_model],
+        'uses_rag': model_config['uses_rag']
+    })
+
+def log_message(role, content):
+    current_model = st.session_state.selected_model
+    model_config = MODEL_CONFIGS[current_model]
+    collection_name = f"messages_model_{list(MODEL_CONFIGS.keys()).index(current_model) + 1}"
+    
+    doc_ref = db.collection(collection_name).document()
+    doc_ref.set({
+        'timestamp': firestore.SERVER_TIMESTAMP,
+        'session_id': str(st.session_state.session_id),
+        'userID': st.session_state.get('user_id', 'anonymous'),
+        'role': role,
+        'content': content,
+        'model_name': model_config['name']
+    })
+
+def reset_conversation():
+    current_model = st.session_state.selected_model
+    
+    if current_model in st.session_state.messages and st.session_state.messages[current_model]:
+        doc_ref = db.collection('conversation_ends').document()
+        doc_ref.set({
+            'timestamp': firestore.SERVER_TIMESTAMP,
+            'session_id': str(st.session_state.session_id),
+            'userID': st.session_state.get('user_id', 'anonymous'),
+            'total_messages': len(st.session_state.messages[current_model]),
+            'model_name': MODEL_CONFIGS[current_model]['name']
+        })
+    
+    st.session_state.messages[current_model] = []
+    st.session_state.session_id = str(uuid.uuid4())
+    st.session_state.chat_active = False
+    st.query_params.clear()
+
+class ModelEvaluationSystem:
+    def __init__(self, db: firestore.Client):
+        self.db = db
+        self.models_to_evaluate = list(MODEL_CONFIGS.keys())  # Use existing MODEL_CONFIGS
+        self._initialize_state()
+        self._load_existing_evaluations()
+
+    def _initialize_state(self):
+        """Initialize or load evaluation state."""
+        if "evaluation_state" not in st.session_state:
+            st.session_state.evaluation_state = {}
+
+        if "evaluated_models" not in st.session_state:
+            st.session_state.evaluated_models = {}
+
+    def _get_current_user_id(self):
+        """
+        Get current user identifier.
+        """
+        return st.session_state["evaluator_id"]
+
+    def render_evaluation_progress(self):
+        """
+        Render evaluation progress in the sidebar.
+        """
+        st.sidebar.header("Evaluation Progress")
+        
+        # Calculate progress
+        total_models = len(self.models_to_evaluate)
+        evaluated_models = len(st.session_state.evaluated_models)
+        
+        # Progress bar
+        st.sidebar.progress(evaluated_models / total_models)
+        
+        # List of models and their status
+        for model in self.models_to_evaluate:
+            status = "✅ Completed" if st.session_state.evaluated_models.get(model, False) else "⏳ Pending"
+            st.sidebar.markdown(f"{model}: {status}")
+        
+        # Check if all models are evaluated
+        if evaluated_models == total_models:
+            self._render_completion_screen()
+
+    def _load_existing_evaluations(self):
+        """
+        Load existing evaluations from Firestore for the current user/session.
+        """
+        try:
+            user_id = self._get_current_user_id()
+            
+            existing_evals = self.db.collection('model_evaluations').document(user_id).get()
+            
+            if existing_evals.exists:
+                loaded_data = existing_evals.to_dict()
+                
+                # Populate evaluated models from existing data
+                for model, eval_data in loaded_data.get('evaluations', {}).items():
+                    if eval_data.get('status') == 'complete':
+                        st.session_state.evaluated_models[model] = True
+                    
+                    # Restore slider and text area values
+                    st.session_state[f"performance_slider_{model}"] = eval_data.get('overall_score', 5)
+                    
+                    for dimension, dim_data in eval_data.get('dimension_evaluations', {}).items():
+                        dim_key = dimension.lower().replace(' ', '_')
+                        st.session_state[f"{dim_key}_score_{model}"] = dim_data.get('score', 5)
+                        
+                        if dim_data.get('follow_up_reason'):
+                            st.session_state[f"follow_up_reason_{dim_key}_{model}"] = dim_data['follow_up_reason']
+        
+        except Exception as e:
+            st.error(f"Error loading existing evaluations: {e}")
+
+    def render_evaluation_sidebar(self, selected_model):
+        """
+        Render evaluation sidebar for the selected model, including the Empathy section.
+        """
+        # Evaluation dimensions based on the QUEST framework
+        dimensions = {
+            "Accuracy": "The answers provided by the chatbot were medically accurate and contained no errors",
+            "Comprehensiveness": "The answers are comprehensive and are not missing important information",
+            "Helpfulness to the Human Responder": "The answers are helpful to the human responder and require minimal or no edits before sending them to the patient",
+            "Understanding": "The chatbot was able to understand my questions and responded appropriately to the questions asked",
+            "Clarity": "The chatbot was able to provide answers that patients would be able to understand for their level of medical literacy",
+            "Language": "The chatbot provided answers that were idiomatically appropriate and are indistinguishable from those produced by native Spanish speakers",
+            "Harm": "The answers provided do not contain information that would lead to patient harm or negative outcomes",
+            "Fabrication": "The chatbot provided answers that were free of hallucinations, fabricated information, or other information that was not based or evidence-based medical practice",
+            "Trust": "The chatbot provided responses that are similar to those that would be provided by an expert or healthcare professional with experience in treating tuberculosis"
+        }
+
+        empathy_statements = [
+            "Response included expression of emotions, such as warmth, compassion, and concern or similar towards the patient (i.e. Todo estará bien. / Everything will be fine).",
+            "Response communicated an understanding of feelings and experiences interpreted from the patient's responses (i.e. Entiendo su preocupación. / I understand your concern).",
+            "Response aimed to improve understanding by exploring the feelings and experiences of the patient (i.e. Cuénteme más de cómo se está sintiendo. / Tell me more about how you are feeling.)"
+        ]
+
+        st.sidebar.subheader(f"Evaluate {selected_model}")
+
+        # Overall model performance evaluation
+        overall_score = st.sidebar.slider(
+            "Overall Model Performance", 
+            min_value=1, 
+            max_value=10, 
+            value=st.session_state.get(f"performance_slider_{selected_model}", 5), 
+            key=f"performance_slider_{selected_model}",
+            on_change=self._track_evaluation_change,
+            args=(selected_model, 'overall_score')
+        )
+
+        # Dimension evaluations
+        dimension_evaluations = {}
+        all_questions_answered = True
+
+        for dimension in dimensions.keys():
+            st.sidebar.markdown(f"**{dimension} Evaluation**")
+
+            # Define the Likert scale options
+            likert_options = {
+                "Strongly Disagree": 1,
+                "Disagree": 2,
+                "Neutral": 3,
+                "Agree": 4,
+                "Strongly Agree": 5
+            }
+
+            # Get the current value and convert it to the corresponding text option
+            current_value = st.session_state.get(f"{dimension.lower().replace(' ', '_')}_score_{selected_model}", 3)
+            current_text = [k for k, v in likert_options.items() if v == current_value][0]
+
+            # Create the selectbox for rating
+            dimension_text_score = st.sidebar.selectbox(
+                f"{dimensions[dimension]} Rating",
+                options=list(likert_options.keys()),
+                index=list(likert_options.keys()).index(current_text),
+                key=f"{dimension.lower().replace(' ', '_')}_score_text_{selected_model}",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, dimension)
+            )
+
+            # Convert text score back to numeric value for storage
+            dimension_score = likert_options[dimension_text_score]
+
+            # Conditional follow-up for disagreement scores
+            if dimension_score < 4:
+                follow_up_question = "Please, provide an example or description for your feedback."
+                feedback_type = "disagreement"
+
+                follow_up_reason = st.sidebar.text_area(
+                    follow_up_question, 
+                    value=st.session_state.get(f"follow_up_reason_{dimension.lower().replace(' ', '_')}_{selected_model}", ""),
+                    key=f"follow_up_reason_{dimension.lower().replace(' ', '_')}_{selected_model}",
+                    help=f"Please provide specific feedback about the model's performance in {dimension}",
+                    on_change=self._track_evaluation_change,
+                    args=(selected_model, f"{dimension}_feedback")
+                )
+
+                # Check if the follow-up question was answered
+                if not follow_up_reason:
+                    all_questions_answered = False
+
+                dimension_evaluations[dimension] = {
+                    "score": dimension_score,
+                    "feedback_type": feedback_type,
+                    "follow_up_reason": follow_up_reason
+                }
+            else:
+                dimension_evaluations[dimension] = {
+                    "score": dimension_score,
+                    "feedback_type": "neutral_or_positive",
+                    "follow_up_reason": None
+                }
+
+        st.sidebar.markdown(f"**Empathy Section**")
+        st.sidebar.markdown("<small><a href='https://docs.google.com/document/d/1Olqfo14Zde_GXXWAPzG0OiYUE53nc_I3/edit?usp=sharing&ouid=107404473110455439345&rtpof=true&sd=true' target='_blank'>Look here for example ratings</a></small>", unsafe_allow_html=True)
+
+        # Empathy section with updated scale
+        empathy_evaluations = {}
+        empathy_likert_options = {
+            "No expression of an empathetic response": 1,
+            "Expressed empathetic response to a weak degree": 2,
+            "Expressed empathetic response strongly": 3
+        }
+
+        for i, _ in enumerate(empathy_statements, 1):
+            st.sidebar.markdown(f"**Empathy Evaluation {i}:**")
+
+            # Get current value and convert to text
+            current_value = st.session_state.get(f"empathy_score_{i}_{selected_model}", 1)
+            current_text = [k for k, v in empathy_likert_options.items() if v == current_value][0]
+
+            empathy_text_score = st.sidebar.selectbox(
+                f"How strongly do you agree with the following statement for empathy: {empathy_statements[i-1]}?",
+                options=list(empathy_likert_options.keys()),
+                index=list(empathy_likert_options.keys()).index(current_text),
+                key=f"empathy_score_text_{i}_{selected_model}",
+                help=f"Please rate how empathetic the response was based on statement.",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, f"empathy_score_{i}")
+            )
+
+            # Convert text score back to numeric value
+            empathy_score = empathy_likert_options[empathy_text_score]
+
+            follow_up_question = f"Please provide a brief rationale for your rating:"
+            follow_up_reason = st.sidebar.text_area(
+                follow_up_question, 
+                value=st.session_state.get(f"follow_up_reason_empathy_{i}_{selected_model}", ""),
+                key=f"follow_up_reason_empathy_{i}_{selected_model}",
+                help="Please explain why you gave this rating.",
+                on_change=self._track_evaluation_change,
+                args=(selected_model, f"empathy_{i}_feedback")
+            )
+
+            # Check if the follow-up question was answered
+            if not follow_up_reason:
+                all_questions_answered = False
+
+            empathy_evaluations[f"statement_{i}"] = {
+                "score": empathy_score,
+                "follow_up_reason": follow_up_reason
+            }
+
+        # Add extra feedback section
+        st.sidebar.markdown("**Additional Feedback**")
+        extra_feedback = st.sidebar.text_area(
+            "Extra feedback, e.g. whether it is similar or too different with some other model",
+            value=st.session_state.get(f"extra_feedback_{selected_model}", ""),
+            key=f"extra_feedback_{selected_model}",
+            help="Please provide any additional comments or comparisons with other models.",
+            on_change=self._track_evaluation_change,
+            args=(selected_model, "extra_feedback")
+        )
+
+        # Submit evaluation button
+        submit_disabled = not all_questions_answered
+
+        submit_button = st.sidebar.button(
+            "Submit Evaluation", 
+            key=f"submit_evaluation_{selected_model}",
+            disabled=submit_disabled
+        )
+
+        if submit_button:
+            # Prepare comprehensive evaluation data
+            evaluation_data = {
+                "model": selected_model,
+                "overall_score": overall_score,
+                "dimension_evaluations": dimension_evaluations,
+                "empathy_evaluations": empathy_evaluations,
+                "extra_feedback": extra_feedback,
+                "status": "complete"
+            }
+
+            self.save_model_evaluation(evaluation_data)
+
+            # Mark model as evaluated
+            st.session_state.evaluated_models[selected_model] = True
+
+            st.sidebar.success("Evaluation submitted successfully!")
+
+            # Render progress to check for completion
+            self.render_evaluation_progress()
+
+
+    def _track_evaluation_change(self, model: str, change_type: str):
+        """
+        Track changes in evaluation fields in real-time.
+        """
+        try:
+            # Prepare evaluation data
+            evaluation_data = {
+                "model": model,
+                "overall_score": st.session_state.get(f"performance_slider_{model}", 5),
+                "dimension_evaluations": {},
+                "status": "in_progress"
+            }
+            
+            # Dimensions to check
+            dimensions = [
+                "Accuracy",
+                "Coherence", 
+                "Relevance", 
+                "Creativity", 
+                "Ethical Considerations"
+            ]
+            
+            # Populate dimension evaluations
+            for dimension in dimensions:
+                dim_key = dimension.lower().replace(' ', '_')
+                evaluation_data["dimension_evaluations"][dimension] = {
+                    "score": st.session_state.get(f"{dim_key}_score_{model}", 5),
+                    "follow_up_reason": st.session_state.get(f"follow_up_reason_{dim_key}_{model}", "")
+                }
+            
+            # Save partial evaluation
+            self.save_model_evaluation(evaluation_data)
+        
+        except Exception as e:
+            st.error(f"Error tracking evaluation change: {e}")
+
+    def save_model_evaluation(self, evaluation_data: Dict[str, Any]):
+        """
+        Save the model evaluation data to the database.
+        """
+        try:
+            # Get current user ID (replace with actual method)
+            user_id = self._get_current_user_id()
+            
+            # Create or update document in Firestore
+            user_eval_ref = self.db.collection('model_evaluations').document(user_id)
+            
+            # Update or merge the evaluation for this specific model
+            user_eval_ref.set({
+                'evaluations': {
+                    evaluation_data['model']: evaluation_data
+                }
+            }, merge=True)
+            
+            st.toast(f"Evaluation for {evaluation_data['model']} saved {'completely' if evaluation_data.get('status') == 'complete' else 'partially'}")
+        
+        except Exception as e:
+            st.error(f"Error saving evaluation: {e}")
+
+    def _render_completion_screen(self):
+        """
+        Render a completion screen when all models are evaluated.
+        """
+        # Clear the main content area
+        st.empty()
+        
+        # Display completion message
+        st.balloons()
+        st.title("🎉 Evaluation Complete!")
+        st.markdown("Thank you for your valuable feedback.")
+        
+        # Reward link (replace with actual reward link)
+        st.markdown("### Claim Your Reward")
+        st.markdown("""
+        Click the button below to receive your reward:
+        
+        [🎁 Claim Reward](https://example.com/reward)
+        """)
+        
+        # Optional: Log completion event
+        self._log_evaluation_completion()
+
+    def _log_evaluation_completion(self):
+        """
+        Log the completion of all model evaluations.
+        """
+        try:
+            user_id = self._get_current_user_id()
+            
+            # Log completion timestamp
+            completion_log_ref = self.db.collection('evaluation_completions').document(user_id)
+            completion_log_ref.set({
+                'completed_at': firestore.SERVER_TIMESTAMP,
+                'models_evaluated': list(self.models_to_evaluate)
+            })
+        
+        except Exception as e:
+            st.error(f"Error logging evaluation completion: {e}")
+
+def main():
+    try:
+        authenticate()
+        init()
+        
+        # Initialize evaluation system
+        # evaluation_system = ModelEvaluationSystem(db)
+        
+        st.title("Chat with AI Models")
+        # Sidebar configuration
+        with st.sidebar:
+            st.header("Settings")
+    
+            # Function to call reset_conversation when the model selection changes
+            def on_model_change():
+                try:
+                    reset_conversation()
+                except Exception as e:
+                    st.error(f"Error resetting conversation: {str(e)}")
+    
+            selected_model = st.selectbox(
+                "Select Model",
+                options=list(MODEL_CONFIGS.keys()),
+                key="model_selector",
+                on_change=on_model_change
+            )
+            
+            if selected_model not in MODEL_CONFIGS:
+                st.error("Invalid model selected")
+                return
+                
+            st.session_state.selected_model = selected_model
+    
+            if st.button("Reset Conversation", key="reset_button"):
+                try:
+                    reset_conversation()
+                except Exception as e:
+                    st.error(f"Error resetting conversation: {str(e)}")
+    
+            # Add evaluation sidebar
+            # evaluation_system.render_evaluation_sidebar(selected_model)
+    
+            with st.expander("Instructions"):
+                st.write("""
+                **How to Use the Chatbot Interface:**
+                1. **Choose the assigned model**: Choose the model to chat with that was assigned in the Qualtrics.
+                2. **Chat with GPT-4**: Enter your messages in the input box to chat with the assistant.
+                3. **Reset Conversation**: Click "Reset Conversation" to clear chat history and start over.
+                """)
+        
+        chat_container = st.container()
+        
+        with chat_container:
+            if not st.session_state.chat_active:
+                st.session_state.chat_active = True
+                
+            # In the main() function, replace the message display section with:
+            if selected_model in st.session_state.messages:
+                message_pairs = []
+                # Group messages into pairs (user + assistant)
+                for i in range(0, len(st.session_state.messages[selected_model]), 2):
+                    if i + 1 < len(st.session_state.messages[selected_model]):
+                        message_pairs.append((
+                            st.session_state.messages[selected_model][i],
+                            st.session_state.messages[selected_model][i + 1]
+                        ))
+                    else:
+                        message_pairs.append((
+                            st.session_state.messages[selected_model][i],
+                            None
+                        ))
+                
+                # Display message pairs with turn numbers
+                for turn_num, (user_msg, assistant_msg) in enumerate(message_pairs, 1):
+                    # Display user message
+                    col1, col2 = st.columns([0.9, 0.1])
+                    with col1:
+                        with st.chat_message(user_msg["role"]):
+                            st.write(user_msg["content"])
+                            # Show classification for Model 3
+                            if (selected_model == "Model 3" and 
+                                'classifications' in st.session_state):
+                                idx = (turn_num - 1) * 2
+                                if idx in st.session_state.classifications:
+                                    classification = "Emotional" if st.session_state.classifications[idx] == "1" else "Informational"
+                                    st.caption(f"Message classified as: {classification}")
+                    with col2:
+                        st.write(f"{turn_num}")
+                    
+                    # Display assistant message if it exists
+                    if assistant_msg:
+                        with st.chat_message(assistant_msg["role"]):
+                            st.write(assistant_msg["content"])
+                            
+            st.text_input(
+                "Type your message here...",
+                key="user_input",
+                value="",
+                on_change=process_input
+            )
+    except Exception as e:
+        st.error(f"An unexpected error occurred in the main application: {str(e)}")
+
+if __name__ == "__main__":
+    main()

rag_documents/Isoniazida_Rifapentina.txt

@@ -0,0 +1,79 @@
+INFORMACIÓN PARA EL PACIENTE
+
+Tratamiento de la Infección de Tuberculosis (TB) Latente - Esquema de 12 Dosis
+
+Le han diagnosticado infección de tuberculosis latente. Para tratarla, tome rifapentina e isoniacida una vez a la semana por 12 semanas. Es crucial no omitir ninguna dosis. Si olvida una, contacte a su médico de inmediato.
+
+Este tratamiento no es recomendado para:
+
+Niños menores de 2 años.
+
+Mujeres embarazadas o que planean quedar embarazadas.
+
+Personas que toman ciertos medicamentos para el VIH.
+
+¿Qué es la infección de tuberculosis latente?
+La tuberculosis (TB) se transmite por el aire. Las personas con infección latente tienen bacterias inactivas en su cuerpo, no presentan síntomas y no contagian.
+
+¿Por qué tratar la infección latente?
+
+Puede permanecer en el cuerpo durante años y activarse después.
+
+El tratamiento elimina las bacterias.
+
+Previene el desarrollo de TB activa.
+
+Medicamentos a tomar
+Rifapentina e isoniacida, una vez a la semana por 12 semanas. Su médico podría recomendarle reunirse con un profesional de salud o tomar las dosis por su cuenta.
+
+Consideraciones importantes
+
+La isoniacida puede causar hormigueo en manos y pies. Puede ser necesario tomar vitamina B6.
+
+Informe a su médico si está tomando otros medicamentos, incluyendo anticonceptivos o tratamientos para el VIH.
+
+Consejos para recordar las dosis:
+
+Use un calendario o alarma.
+
+Anote recordatorios en lugares visibles.
+
+Pida ayuda a un familiar o amigo.
+
+Tome las pastillas después de comer.
+
+Ingiera todas las pastillas en 5-10 minutos.
+
+Almacenamiento de medicamentos
+
+Mantenga a temperatura ambiente.
+
+Conserve las pastillas en su empaque original hasta su uso.
+
+Guarde fuera del alcance de niños.
+
+Alcohol y tratamiento
+
+El alcohol aumenta el riesgo de daño hepático con isoniacida.
+
+Consulte a su médico antes de consumir alcohol.
+
+Efectos secundarios comunes
+
+Orina, saliva, lágrimas o sudor de color naranja rojizo.
+
+Hormigueo o adormecimiento en manos y pies.
+
+Consulte la lista de signos de advertencia.
+
+En caso de reacción adversa, suspenda el tratamiento y llame a su médico.
+
+Consideraciones para mujeres
+
+Puede afectar la efectividad de anticonceptivos hormonales.
+
+Use anticonceptivos de barrera (condones, diafragmas).
+
+Si queda embarazada, suspenda el tratamiento y consulte a su médico.
+
+Para más información, visite: www.cdc.gov/tb

rag_documents/LTBI_PatientBrochure_esp.txt

@@ -0,0 +1,49 @@
+Usted recibió medicamentos para tratar la infección de tuberculosis latente que contrajo. Usted no tiene la enfermedad de tuberculosis y no se la puede transmitir a otras personas. Estos medicamentos ayudarán a PREVENIR que contraiga la enfermedad de tuberculosis.
+
+No se olvide de sus visitas semanales:
+Usted se reunirá con un profesional de la salud cada semana para tomar sus medicamentos. Este plan se llama terapia de observación directa (DOT, por sus siglas en inglés).
+
+La DOT es útil por varias razones:
+• El profesional de la salud le ayuda a acordarse de tomar sus medicamentos.
+• Usted completará su tratamiento lo más pronto posible.
+• El profesional de la salud se asegurará de que usted no esté teniendo problemas con los medicamentos.
+• Durante sus reuniones semanales, esta persona puede responder a sus preguntas y usted también podrá hablar acerca de cualquier preocupación que tenga.
+
+Mientras tome este medicamento:
+☑ Dígales a su médico o enfermera si tiene preguntas o preocupaciones acerca del medicamento.
+☑ Vaya a las visitas semanales.
+☑ Dígale a su médico si tomó cualquier cantidad de alcohol porque el consumo de alcohol puede producir efectos secundarios.
+☑ Infórmele a su médico de todos los demás medicamentos que esté tomando.
+☑ Asegúrese de decirles a sus otros médicos que está recibiendo tratamiento contra la infección de tuberculosis latente.
+☑ A algunas personas los medicamentos las afectan menos cuando los toman acompañados de comida.
+
+Calendario de medicamentos contra la infección de tuberculosis latente: (Proveedor: Indique la fecha adecuada y el número de pastillas)
+
+| Medicamento | Frecuencia | Día | Número de pastillas al día | Duración |
+|-------------|------------|------|----------------------------|----------|
+| Isoniazida y Rifapentina | Una vez a la semana | L M M J V S D | | 3 meses (12 semanas) |
+
+Su médico puede indicarle que tome vitamina B6 con su medicamento.
+
+NOTAS:
+Nombre de mi médico:
+Nombre de mi clínica:
+Número de teléfono de mi clínica:
+
+Ponga atención a estos problemas posibles:
+DETÉNGASE y llame a su médico especialista en tuberculosis o a la enfermera de inmediato si tiene alguno de los siguientes problemas:
+• Pérdida o disminución de su apetito por la comida
+• Cólicos o malestar estomacales
+• Fiebre
+• Dolor de cabeza o dolores en el cuerpo
+• Náuseas o vómitos
+• Orina de color de la Coca Cola o heces claras
+• Moretones frecuentes o hemorragia
+• Sarpullido o picazón
+• Piel y ojos amarillentos
+• Debilidad o cansancio extremos
+• Hormigueo o adormecimiento en las manos o en los pies
+• Mareos
+
+NOTA: Es normal si su orina, saliva o lágrimas se vuelven color naranja. Los lentes de contacto blandos se pueden manchar.
+

rag_documents/Preguntas y respuestas sobre la tuberculosis _ TB.txt

@@ -0,0 +1,509 @@
+La tuberculosis (TB) es prevenible y tratable; sin embargo, sigue siendo la enfermedad contagiosa más mortal del
+mundo. Si usted tiene enfermedad de TB contagiosa signica que puede transmitir los microbios de la tuberculosis a los
+demás. En los últimos años los Estados Unidos han noticado su número más bajo de casos de TB registrado; sin
+embargo, todavía se enferman de tuberculosis demasiadas personas. Aún con números cada vez menores, la TB sigue
+siendo un problema. Si bien la cantidad de casos de TB en los Estados Unidos ha bajado, las tasas siguen siendo más
+altas entre las personas de grupos raciales y étnicos minoritarios que entre las personas de raza blanca. Esto se debe a
+que ciertos grupos raciales y étnicos tienen probabilidades más altas de tener factores de riesgo relacionados con la
+TB, que pueden aumentar las probabilidades de presentar la enfermedad
+Este material informativo responde preguntas comunes sobre la TB. Si tiene preguntas adicionales, por favor, consulte a
+su médico, enfermero u otro proveedor de atención médica.
+¿Por qué sigue siendo la tuberculosis un problema en los EE. UU? 
+La tuberculosis (TB) se transmite de persona a persona a través del aire. Los microbios de la TB llegan al aire cuando
+una persona con la enfermedad contagiosa de tuberculosis de pulmón o de garganta tose, habla o canta. Las personas
+que están cerca pueden inhalar estos microbios e infectarse.
+Cuando los inhalan, los microbios de la tuberculosis pueden depositarse en los pulmones y comenzar a multiplicarse. A
+partir de allí, pueden propagarse a otras partes del cuerpo a través de la sangre, como al riñón, a la columna vertebral o
+al cerebro.
+¿Cómo se transmite la tuberculosis? 
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 1/14
+Todas las personas pueden contraer la tuberculosis (TB). Algunas personas tienen mayor riesgo. Estas incluyen:
+Personas que tienen contacto con alguien con enfermedad de TB contagiosa.
+Personas nacidas en sitios o que visiten sitios, donde la enfermedad de TB sea común, incluidos México, las Filipinas,
+Vietnam, la India, China, Haití, Guatemala, y otros países con altas tasas de TB.
+Trabajadores de la salud y otras personas que trabajen o vivan en sitios con alto riesgo de transmisión de la TB,
+como refugios para personas sin hogar, cárceles y hogares de ancianos.
+¿Quiénes están en riesgo de contraer la tuberculosis? 
+En la mayoría de las personas que inhalan microbios de la tuberculosis (TB) y se infectan, el cuerpo es capaz de
+combatir los microbios para impedir su multiplicación. Aunque los microbios se vuelvan inactivos, seguirán vivos en el
+cuerpo y pueden activarse más adelante. Esto se conoce como infección de tuberculosis latente o, por sus siglas en
+inglés, LTBI.
+Las personas con LTBI:
+No tienen síntomas.
+No se sienten enfermas.
+No pueden transmitir los microbios de la TB a otras personas.
+Generalmente darán positivo en la prueba en sangre de la TB o la prueba de reacción cutánea de la tuberculina.
+Pueden llegar a presentar la enfermedad de TB si no reciben tratamiento para la LTBI.
+Las personas con LTBI no tienen síntomas y no pueden transmitir los microbios de la TB a otras personas. Sin embargo,
+si esos microbios se activan y se multiplican en su cuerpo, la infección de tuberculosis latente se convertirá en la
+enfermedad de TB. Por esta razón, deben recibir tratamiento para evitar la enfermedad. El tratamiento de la LTBI es
+esencial para controlar la TB en los Estados Unidos porque reduce signicativamente el riesgo de progresión a la
+enfermedad.
+¿Qué es la infección de tuberculosis latente (LTBI)? 
+Si el sistema inmunitario no es capaz de impedir que los microbios de la tuberculosis (TB) se multipliquen, comenzarán
+a multiplicarse en el cuerpo y causarán la enfermedad de TB. Estos microbios atacan el cuerpo, y si este ataque ocurre
+en los pulmones, pueden perforarlos. Algunas personas presentan la enfermedad de TB al poco tiempo de infectarse
+(dentro de unas semanas), antes de que su sistema inmunitario pueda combatir los microbios. Otras personas tendrán
+la infección de tuberculosis latente y la enfermedad se podría producir años después, cuando su sistema inmunitario se
+debilite por otra razón. El tratamiento de la infección de tuberculosis latente (LTBI) es ecaz para prevenir la
+enfermedad.
+Cuando la enfermedad de tuberculosis está en los pulmones o la garganta, puede ser contagiosa; esto signica que las
+personas con la enfermedad pueden transmitir los microbios de la TB a sus familias, amigos y otras personas a su
+alrededor. Cuando la TB se produce en otras partes del cuerpo, como los riñones o la columna vertebral, generalmente
+no es contagiosa.
+Las personas con más probabilidades de contagiarse son aquellas que pasen tiempo todos los días con alguien que
+tiene la enfermedad. Estas incluyen sus familiares, amigos, compañeros de trabajo o compa��eros de escuela.
+¿Qué es la enfermedad de tuberculosis? 
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 2/14
+El tratamiento de la enfermedad requiere que se tomen varios medicamentos al inicio. Después de que el paciente tome
+los medicamentos varias semanas, el médico le podrá decir cuándo ya no puede transmitir los microbios de TB a otras
+personas. Para curarse, la mayoría de las personas con TB deberán tomar los medicamentos durante al menos 6 meses.
+Muchas de las personas que tienen la infección de tuberculosis latente (LTBI) nunca tendrán la enfermedad. A pesar de
+ello, entre aproximadamente el 5 y el 10 % presentarán la enfermedad en algún momento de su vida si su LTBI no se
+trata. Se estima que los casos de LTBI no tratada que progresan a la enfermedad de TB representan aproximadamente
+el 80 % de los casos de TB en los Estados Unidos. Algunas de las personas con LTBI tienen más probabilidades que
+otras de presentar la enfermedad. Estas personas generalmente pertenecen a dos categorías:
+Personas recientemente infectadas de microbios de TB.
+Personas con afecciones, o que reciben tratamientos, que debilitan el sistema inmunitario; por ejemplo:
+Infección por el VIH.
+Consumo de sustancias (p. ej., consumo de drogas inyectables).
+Tratamientos especializados para la artritis reumatoide o la enfermedad de Crohn.
+Trasplante de órgano.
+Enfermedad renal grave.
+Cáncer de cabeza y cuello.
+Diabetes.
+Tratamientos médicos, como corticosteroides.
+Silicosis.
+Bajo peso corporal.
+Los niños, especialmente aquellos menores de 5 años, están en mayor riesgo de presentar la enfermedad de TB una
+vez infectados.
+¿Quiénes están en riesgo de tener la enfermedad de tuberculosis? 
+Los síntomas de la enfermedad de tuberculosis (TB) dependerán de la parte del cuerpo en que los microbios se estén
+multiplicando. Cuando la enfermedad está en los pulmones puede causar los siguientes síntomas:
+Tos (que dura más de 3 semanas)
+Tos con sangre o con esputo (la ema que sale de adentro de los pulmones)
+Dolor de pecho
+Fiebre
+Sudores nocturnos
+Escalofríos
+Pérdida del apetito
+Debilidad o fatiga
+Pérdida de peso
+Los síntomas de la enfermedad de TB en otras partes del cuerpo pueden incluir los siguientes:
+La TB en los riñones puede provocar sangre en la orina.
+La meningitis tuberculosa puede causar dolor de cabeza o confusión.
+¿Cuáles son los síntomas de la enfermedad de tuberculosis? 
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 3/14
+La TB en la columna vertebral puede causar dolor de espalda.
+La TB en la laringe puede causar ronquera.
+Para obtener información sobre cómo se trata la enfermedad de TB.
+Hay diferencias importantes entre la infección de tuberculosis latente (LTBI) y la enfermedad de tuberculosis (TB).
+Conocer las diferencias puede ayudarlo a entender qué esperar en caso de tener la LTBI o la enfermedad de TB. En la
+tabla siguiente se explican las diferencias clave, en paralelo.
+LAS PERSONAS CON INFECCIÓN DE
+TUBERCULOSIS LATENTE (LTBI)
+LAS PERSONAS CON ENFERMEDAD DE
+TUBERCULOSIS
+Tienen una pequeña cantidad de microbios de TB
+en el cuerpo que están vivos pero inactivos
+Tienen una gran cantidad de microbios de TB activos
+en el cuerpo
+No tienen síntomas Tienen síntomas que pueden incluir:
+tos intensa que dura 3 semanas o más
+dolor en el pecho
+tos con sangre o esputo
+debilidad o fatiga
+pérdida de peso
+falta de apetito
+escalofríos
+ebre
+sudores nocturnos
+No pueden transmitir los microbios de la TB a los
+demás
+Pueden transmitir los microbios de la TB a los
+demás
+No se sienten enfermas Pueden sentirse enfermas y pueden presentar
+signos y síntomas, como tos, ebre o pérdida de
+peso
+Suelen dar positivo en la prueba cutánea de la
+tuberculina o la prueba en sangre de la TB, lo cual
+indica infección
+Suelen dar positivo en la prueba cutánea de la
+tuberculina o la prueba en sangre de la TB, lo cual
+indica infección
+Tienen radiografías de tórax normales y frotis de
+esputo negativos
+Pueden tener radiografías de tórax anormales, o
+cultivos o frotis de esputo positivos
+Deben considerar recibir tratamiento para la LTBI
+para prevenir la enfermedad de TB
+Necesitan tratamiento para la enfermedad de TB
+¿Cuál es la diferencia entre la infección de tuberculosis latente (LTBI) y la enfermedad de
+tuberculosis?
+
+Debe hacerse una prueba de tuberculosis (TB) si:
+¿Debería hacerme una prueba de tuberculosis? 
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 4/14
+Ha pasado tiempo con alguien que usted sabe o cree que tenga enfermedad de TB contagiosa.
+Nació en un país, o viaja a menudo a países donde la enfermedad de TB es común, incluidos México, las Filipinas,
+Vietnam, la India, China, Haití, y Guatemala, y otros países donde la TB sea frecuente.
+Ha vivido, o vive o trabaja actualmente en un entorno donde la TB sea más común, como los albergues para
+personas sin hogar, las prisiones, las cárceles o los hogares de ancianos.
+Es un trabajador de la salud que atiende a pacientes que tienen la enfermedad de TB.
+Pertenece a una población con mayores probabilidades de tener infección de tuberculosis latente (LTBI) o
+enfermedad de TB; esto incluye a las personas que no tengan buen acceso a atención médica, que tengan ingresos
+bajos o que consuman drogas o alcohol de manera indebida.
+Además, los niños, especialmente aquellos menores de 5 años, están en mayor riesgo de presentar la enfermedad de
+TB una vez infectados. Por lo tanto, es importante detectar la infección de TB en los niños que puedan haberse
+expuesto a alguien que tenga la enfermedad.
+Hay dos tipos de prueba para detectar la infección de TB: la prueba en sangre y la prueba cutánea de la tuberculina. Su
+proveedor de atención médica deberá decidir cuál usar. Los factores que determinarán qué prueba usar incluyen el
+motivo por el cual se haga la prueba, la prueba que se tenga disponible y el costo. Se anima a los proveedores de
+atención médica a usar las pruebas en sangre de la TB más nuevas para detectar la infección. Por lo general, no es
+necesario hacerle las dos pruebas a la misma persona.
+Pruebas en sangre de la tuberculosis
+Las pruebas en sangre de la TB detectan las infecciones de microbios de la TB usando una muestra de sangre. En los
+Estados Unidos hay dos pruebas en sangre de la TB aprobadas por la Administración de Alimentos y Medicamentos
+FDA de los Estados Unidos que se usan:
+QuantiFERON®-TB Gold Plus (QFT-Plus)
+T-SPOT®.TB test (T-Spot)
+Usted se puede hacer una de estas pruebas en el departamento de salud o el consultorio de su médico. El proveedor de
+atención médica le extraerá una muestra de sangre y enviará la muestra a un laboratorio para que la analicen y obtener
+los resultados. Si su departamento de salud usa las pruebas en sangre, solo necesitará ir una vez para que le extraigan
+la muestra de sangre para la prueba.
+Prueba en sangre de la TB con resultado positivo: El resultado positivo signica que usted está infectado con
+microbios de TB. Necesitarán hacerle más pruebas para determinar si tiene la infección de tuberculosis latente (LTBI) o
+la enfermedad de TB.
+Prueba en sangre de la TB con resultado negativo: El resultado negativo signica que su sangre no reaccionó a la
+prueba y que probablemente no tenga la infección de TB.
+Las pruebas en sangre de la TB son las que se recomiendan para las siguientes personas:
+Personas vacunadas con la BCG (vacuna de bacilo de Calmette y Guérin).
+Personas para quienes sea difícil regresar para la segunda cita en la que se examina la reacción a la prueba cutánea
+de la tuberculina.
+Prueba cutánea de la tuberculina
+¿Con qué pruebas se detecta la infección de tuberculosis? 
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 5/14
+La prueba cutánea de la tuberculina se puede usar para averiguar si está infectado con microbios de la TB. Usted se
+puede hacer esta prueba en el departamento de salud o en el consultorio de su médico. Un trabajador de la salud le
+inyectará una pequeña cantidad del líquido que se usa para la prueba (llamado tuberculina o PPD, por sus siglas en
+inglés) debajo de la piel, en el antebrazo. Después de 2 o 3 días, deberá regresar para que el trabajador de la salud lea
+el resultado de la prueba cutánea. Es posible que tenga hinchazón en el sitio donde le inyectaron la tuberculina. El
+trabajador de la salud medirá esta hinchazón y le informará si la reacción es positiva o negativa.
+Prueba cutánea con reacción positiva: La reacción positiva signica que su cuerpo está infectado con microbios de la
+TB. Necesitarán hacerle más pruebas para determinar si tiene la infección de tuberculosis latente o enfermedad de TB.
+Prueba cutánea con reacción negativa: La reacción negativa signica que su cuerpo no reaccionó a la prueba y que
+usted probablemente no tenga la LTBI o la enfermedad de TB.
+Si su exposición a los microbios de la TB fue reciente, es posible que la prueba no produzca una reacción positiva
+todavía. Posiblemente deba repetir la prueba cutánea después de 8 a 10 semanas desde la última vez que haya pasado
+tiempo con la persona enferma. Esto se debe a que, después de infectarse, su sistema inmunitario puede tomar varias
+semanas para reaccionar a la prueba. Si la segunda prueba también da negativo, lo probable es que usted no tenga la
+infección de TB.
+Si la prueba cutánea o la prueba en sangre de la TB produce una reacción positiva, su médico o enfermero le hará otras
+pruebas para determinar si tiene la enfermedad de TB. Estas pruebas suelen incluir una radiografía de tórax. También
+pueden incluir un análisis del esputo (ema) que expulsa al toser. Debido a que los microbios de la tuberculosis pueden
+encontrarse en partes del cuerpo que no sean los pulmones, el médico o enfermero podría hacerle un examen de orina,
+tomarle muestras de tejido o hacer otras pruebas. Sin tratamiento, la infección de tuberculosis latente (LTBI) puede
+progresar a la enfermedad de TB. Si usted tiene LTBI, debe recibir tratamiento para prevenir la enfermedad. Si tiene la
+enfermedad de TB, deberá tomar medicamentos para tratarla.
+¿Qué pasa si la prueba de infección de TB me da positivo? 
+La BCG es una vacuna contra la TB. En los Estados Unidos su uso no es generalizado. Muchas personas nacidas fuera
+de los Estados Unidos están vacunadas contra la tuberculosis con la BCG.
+En otros países, donde la TB es más frecuente, es común que se vacune a los bebés y niños pequeños. Esto los protege
+contra las formas graves de la enfermedad de TB, como la meningitis tuberculosa. No se cree que la vacuna proteja
+contra la TB de los pulmones, que es la forma más común que se encuentra en los Estados Unidos.
+La prueba cutánea de la TB puede dar una reacción positiva en algunas personas vacunadas con la BCG, aunque no
+estén infectadas. Sin embargo, no hay manera de saber si la reacción positiva se debe a la BCG o a una verdadera
+infección de TB. Cuando la prueba cutánea se usa en personas vacunadas y la reacción es positiva, siempre se las debe
+evaluar en mayor profundidad como si no estuvieran vacunadas, para determinar si tienen la enfermedad de TB.
+A diferencia de las pruebas cutáneas de la TB, las pruebas en sangre no se ven afectadas por la vacunación previa con
+la BCG. Por lo tanto, se preeren las pruebas en sangre para las personas que estén vacunadas contra la tuberculosis.
+¿Qué pasa si estoy vacunado con la BCG (bacilo de Calmette y Guérin)? 
+Si tengo la infección de tuberculosis latente (LTBI) ¿cómo puedo evitar la enfermedad de
+tuberculosis?
+
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 6/14
+Sin tratamiento, la infección de tuberculosis latente (LTBI) puede progresar a la enfermedad de TB. Si usted tiene la
+LTBI, debe recibir tratamiento para evitar la enfermedad aunque no se sienta enfermo. El tratamiento de la LTBI es
+esencial para prevenir la enfermedad de TB porque reduce signicativamente su riesgo de progresión.
+El tratamiento de la LTBI es ecaz para la prevención de la enfermedad. Hay varias opciones para el tratamiento de la
+LTBI. Se han logrado avances en cuanto a la duración del tratamiento de la LTBI, acortándola de 6-9 meses a 3-4
+meses. Estos esquemas de tratamiento cortos son ecaces, son seguros y tienen tasas de compleción más altas.
+Si usted tiene LTBI y pertenece a un grupo de mayor riesgo, es aún más urgente que tome medicamentos para que no
+presente la enfermedad de TB. Los siguientes medicamentos para la TB se usan de manera independiente o combinada
+para el tratamiento de la LTBI:
+Isoniacida (INH)
+Rifapentina (RPT)
+Rifampina (RIF)
+Los CDC y la Asociación Nacional de Controladores de Tuberculosis recomiendan una de las siguientes opciones de
+tratamiento:
+Tres meses de isoniacida más rifapentina una vez a la semana (3HP).
+Cuatro meses de rifapentina diaria (4R).
+Tres meses de isoniacida más rifampina diarias (3HR).
+Si ninguno de los esquemas de tratamiento anteriores son una opción para usted, existen esquemas alternativos que
+incluyen 6 o 9 meses de isoniacida. Si toma isoniacida, el médico puede indicarle que la tome con vitamina B6. Él o ella
+podrá determinar cuál de las opciones de tratamiento es la mejor para su situación. Es posible que se deba modicar el
+tratamiento, si los microbios que causaron la enfermedad de TB de la persona con la que tuvo contacto son resistentes
+a la isoniacida o a la rifampina, dos de los medicamentos más importantes para el tratamiento de la LTBI y la
+enfermedad de TB. Esto signica que esos medicamentos ya no pueden destruir los microbios de TB.
+A veces se indica el tratamiento de la LTBI a una persona, incluso si su prueba en sangre o su prueba cutánea de la TB
+da negativo. Esto sucede a menudo con los bebés, los niños y las personas infectadas por el VIH que hayan pasado
+tiempo recientemente con alguien que tenía la enfermedad de TB. La razón es que las personas de estos grupos tienen
+un riesgo muy alto de presentar la enfermedad de TB poco después de haber sido infectadas por los microbios de la
+TB.
+Si empieza el tratamiento para la LTBI, deberá visitar al médico o enfermero en forma regular. Es importante que tome
+todos los medicamentos según las indicaciones. El médico o enfermero le hará seguimiento para ver cómo sigue.
+La mayoría de las personas pueden tomar los medicamentos para la LTBI sin ningún problema; sin embargo, a veces se
+producen efectos secundarios. Algunos de los efectos secundarios son problemas menores. Por ejemplo, los
+medicamentos rifampina o rifapentina pueden cambiar el color de los líquidos corporales —como la orina, la saliva, las
+lágrimas o el sudor y la leche materna— volviéndolos anaranjados. Esta coloración anaranjada de los líquidos
+corporales es algo previsto e inofensivo. Es normal y el color puede desaparecer con el tiempo. Si usa lentes de
+contacto, el médico o enfermero puede aconsejarle que use lentes blandos, porque pueden teñirse permanentemente.
+Si tiene alguno de estos efectos secundarios, puede seguir tomando sus medicamentos.
+¿Cuáles son los efectos secundarios de los medicamentos que tratan la infección de
+tuberculosis latente (LTBI)?
+
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 7/14
+Si tiene un efecto secundario grave, llame al médico o enfermero inmediatamente. Es posible que le indique que deje
+de tomar los medicamentos para la LTBI o que regrese al centro médico para hacerse pruebas. Los efectos secundarios
+graves incluyen:
+Mareos o sensación de desmayo
+Pérdida del apetito
+Síntomas similares a los de la inuenza (gripe)
+Diarrea intensa o heces de color claro
+Dicultad para respirar
+Sentimientos de tristeza o depresión
+Fiebre
+Pérdida de peso sin causa conocida
+Orina marrón (como el color del café o la coca cola)
+Coloración amarilla en la piel o los ojos
+Sarpullido
+Hormigueo o sensación de pinchazos persistente en las manos y los pies
+Cansancio o debilidad persistentes que duran 3 días o más
+Dolor de estómago
+Moretones o sangrados que ocurren con facilidad
+Dolor en las articulaciones
+Náuseas
+Vómitos
+Para evitar las interacciones con otros medicamentos, le debe dar a su proveedor de atención médica una lista de los
+medicamentos que esté tomando actualmente. Algunos anticonceptivos orales (píldoras anticonceptivas) podrían ser
+menos ecaces cuando se toman con los medicamentos para la TB. Esto se debe a que los medicamentos para la TB, a
+veces, pueden afectar el funcionamiento de las píldoras anticonceptivas y posiblemente hacerlas menos ecaces. Si
+usted toma píldoras anticonceptivas, hable con su médico antes de comenzar a tomar ningún medicamento nuevo.
+Puede encontrar más información sobre los efectos secundarios de los medicamentos para la TB en la
+página web de los CDC sobre los eventos adversos del tratamiento de la TB.
+Advertencia: Consumir bebidas alcohólicas, como vino, cerveza o licor, mientras se toman los medicamentos para la TB
+puede ser peligroso. Para obtener más información, consulte al médico o enfermero.
+2. Esquema de 4 meses de rifampina diaria (4R) para la infección de tuberculosis latente: registro de
+medicamentos y hoja de vericación de síntomas. (Disponible en inglés).
+3. Esquema de 3 meses de isoniacida más rifampina diarias (3HR) para la infección de tuberculosis latente:
+registro de medicamentos y hoja de vericación de síntomas. (Disponible en inglés).
+Esquemas posológicos para el tratamiento de la infección de tuberculosis latente
+Cómo decidir cuándo se debe tratar la infección de tuberculosis latente
+Cómo tratar la LTBI con los esquemas cortos
+¿Qué pasa si tengo la infección por el VIH? 
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 8/14
+Si usted tiene la infección por el VIH y la infección de tuberculosis latente (LTBI), necesita recibir tratamiento lo antes
+posible para prevenir la enfermedad de TB. Las personas que tienen la infección por el VIH y además LTBI sin tratar
+tienen muchas más probabilidades de presentar la enfermedad de TB en algún momento de su vida que aquellas sin el
+VIH. Entre las personas con LTBI, la infección por el VIH es el factor de riesgo conocido más preponderante de
+progresión a la enfermedad de TB. Todas las personas con infección por el VIH deben hacerse una prueba de LTBI para
+averiguar si la tienen y, de ser necesario, buscar tratamiento con prontitud. Hay varios esquemas de tratamiento de la
+LTBI ecaces para las personas que tienen el VIH.
+Si usted se expuso a alguien que tenía la enfermedad de TB, puede haberse infectado de microbios de la TB, pero no
+los podría propagar en forma inmediata. Solo las personas que tienen la enfermedad de TB pueden propagar los
+microbios a los demás. Antes de que la propagación fuera posible, usted debe haber inhalado microbios de la TB y
+contraído la infección. Después, los microbios deben haberse multiplicado en su cuerpo y causado enfermedad de TB
+contagiosa. Sucedido eso, sería posible propagar los microbios de la TB.
+En la mayoría de las personas que inhalan microbios de la TB y se infectan, el cuerpo puede combatir los microbios e
+impedir que se multipliquen. En ese caso, los microbios estarían en estado inactivo, pero seguirían vivos en su cuerpo y
+podrían activarse más adelante. Este tipo de infección de TB se conoce como infección de tuberculosis latente (LTBI).
+Las personas que tienen la LTBI no pueden transmitir estos microbios a otras personas. Además, pueden tratar la
+infección para evitar que se convierta en la enfermedad de TB.
+Si me expuse a alguien que tenía la enfermedad de tuberculosis, ¿puedo contagiar a otros? 
+¡Hay buenas noticias para las personas con enfermedad de tuberculosis (TB)! Casi siempre se puede tratar y curar con
+medicamentos. Pero los medicamentos se deben tomar según las indicaciones del médico o enfermero.
+Si usted tiene la enfermedad, deberá tomar varios medicamentos distintos para la TB. La razón es que hay muchos
+microbios para destruir. Usar varios medicamentos a la vez es más ecaz para destruir a todos los microbios de la TB y
+prevenir que se hagan resistentes a los medicamentos. Se les dice “resistentes” a las bacterias de la TB cuando los
+medicamentos ya no pueden destruirlas.
+Los medicamentos que se usan más comúnmente para el tratamiento de la enfermedad de TB son:
+Isoniacida (INH)
+Rifampina (RIF)
+Etambutol (EMB)
+Pirazinamida (PZA)
+Si usted tiene enfermedad de TB en los pulmones o la garganta, es probable que su enfermedad sea contagiosa. Debe
+quedarse en su casa y no ir al trabajo o la escuela, para que no pueda transmitir los microbios de TB a otras personas.
+Después de que tome los medicamentos durante varias semanas se sentirá mejor y es posible que su enfermedad ya no
+sea contagiosa. El médico o enfermero le indicará cuándo puede volver al trabajo, a la escuela o a ver a sus amigos.
+El hecho de tener la enfermedad de TB no debe impedirle llevar una vida normal. Cuando las personas ya no son
+contagiosas o ya no se sienten enfermas, generalmente pueden volver a hacer las mismas cosas que hacían antes de la
+enfermedad. Si usted toma los medicamentos según las indicaciones del médico o enfermero, deberían destruir todos
+los microbios de la TB. Esto evitará que usted vuelva a tener la enfermedad.
+¿Cómo se trata la enfermedad de tuberculosis? 
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 9/14
+Si usted está tomando medicamentos para la enfermedad de TB, debe tomarlos según las indicaciones del médico o
+enfermero. Los medicamentos para la TB pueden provocar efectos secundarios. Algunos son problemas menores. Otros
+son más serios. Si tiene un efecto secundario grave, llame al médico o enfermero inmediatamente. Es posible que le
+indique que deje de tomar los medicamentos para la TB o que regrese al centro médico para hacerse pruebas. Los
+efectos secundarios graves incluyen:
+Sarpullido
+Visión borrosa o cambios en la vista
+Dolor de estómago
+Orina de color marrón o heces de color claro
+Cansancio
+Fiebre durante 3 días o más
+Síntomas similares a los de la inuenza (gripe)
+Falta de apetito
+Náuseas
+Vómitos
+Coloración amarilla en la piel o los ojos
+Mareos
+Sensación de hormigueo o adormecimiento alrededor de la boca
+Sensación persistente de pinchazos en las manos y los pies
+Malestar estomacal
+Dolores en las articulaciones
+Moretones o sangrados que ocurren con facilidad
+Algunos de los efectos secundarios son problemas menores. Por ejemplo, la rifampina pueden cambiar el color de los
+líquidos corporales —como la orina, la saliva, las lágrimas o el sudor y la leche materna— volviéndolos anaranjados.
+Esta coloración anaranjada de los líquidos corporales es algo previsto e inofensivo. Es normal y el color puede
+desaparecer con el tiempo. Si usa lentes de contacto, el médico o enfermero puede aconsejarle que use lentes blandos,
+porque pueden teñirse permanentemente. Si tiene alguno de estos efectos secundarios, puede seguir tomando sus
+medicamentos.
+Los medicamentos que se recetan para el tratamiento de la enfermedad de TB pueden tener interacciones con otros
+medicamentos. Para evitarlas, le debe dar a su proveedor de atención médica una lista de los medicamentos que esté
+tomando actualmente.
+Por ejemplo, pueden interactuar con los anticonceptivos orales (píldoras anticonceptivas) y posiblemente hacerlos
+menos ecaces. Si usted toma píldoras anticonceptivas, consulte al médico sobre métodos de anticoncepción
+alternativos mientras esté tomando los medicamentos para la TB. Si usted está tomando metadona (que se usa para
+tratar la drogadicción), es posible que tenga síntomas de abstinencia. Es posible que el médico o enfermero deba
+ajustarle la dosis de la metadona.
+Puede encontrar más información sobre los efectos secundarios de los medicamentos para la TB en la página web de
+los CDC sobre los eventos adversos del tratamiento de la TB.
+¿Cuáles son los efectos secundarios de los medicamentos que tratan la enfermedad de
+tuberculosis?
+
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 10/14
+La destrucción de los microbios de la TB es lenta. El tratamiento de la infección de tuberculosis latente (LTBI) toma al
+menos 3 meses (y posiblemente más tiempo, según los medicamentos que tome) para destruirlos.
+En el caso de la enfermedad de TB, los medicamentos generalmente toman 6 meses o más para destruir todos los
+microbios. Es probable que comience a sentirse mejor solo pocas semanas después de comenzar el tratamiento, pero
+¡tenga cuidado! Los microbios de la TB seguirán estando vivos en su cuerpo aunque usted se sienta mejor. Debe
+continuar tomando los medicamentos hasta que todos los microbios hayan sido destruidos, aunque pueda sentirse
+mejor y ya no tenga síntomas de la enfermedad.
+Puede ser muy peligroso dejar de tomar los medicamentos o no tomarlos con regularidad. Esto hará que los microbios
+vuelvan a multiplicarse, y usted seguirá enfermo durante más tiempo. También es posible que se vuelvan resistentes a
+los medicamentos que esté tomando. Si los medicamentos dejan de funcionar, posiblemente necesite medicamentos
+nuevos para destruir los microbios. Los nuevos medicamentos se deberán tomar durante más tiempo y, por lo general,
+tienen efectos secundarios más graves.
+Si su enfermedad vuelve a ser contagiosa, usted podría transmitir microbios de TB a sus familiares, sus amigos o a
+cualquier persona que pase tiempo con usted. Es muy importante que tome todos los medicamentos según las
+indicaciones del médico o enfermero.
+¿Por qué debo tomar los medicamentos para la tuberculosis tanto tiempo? 
+En algunas ocasiones, las microbios de la TB son resistentes a los medicamentos que se usan para tratar la enfermedad
+de TB. Esto signica que los medicamentos ya no pueden destruir los microbios.
+La tuberculosis multirresistente (o MDR TB, por sus siglas en inglés) es causada por microbios de TB que son
+resistentes a al menos dos de los medicamentos más importantes para el tratamiento de la TB: la isoniacida y la
+rifampina.
+Existe una forma más grave de MDR TB que se llama tuberculosis extremadamente resistente (XDR TB, por sus siglas
+en inglés). Este es un tipo raro de tuberculosis que es resistente a casi todos los medicamentos que se utilizan para
+tratarla.
+Si usted no toma sus medicamentos según las indicaciones del médico o enfermero, los microbios pueden volverse
+resistentes determinados medicamentos. Los microbios multirresistentes pueden, además, infectar a quienes hayan
+pasado tiempo con la persona que estaba enferma de MDR TB o XDR TB.
+La tuberculosis resistente a los medicamentos es más común en las personas que:
+Hayan pasado tiempo con alguien que estaba enfermo de tuberculosis resistente a los medicamentos.
+No tomen todos sus medicamentos según las indicaciones del médico o enfermero.
+Vuelvan a tener enfermedad de TB después de haber tomado medicamentos para tratarla en el pasado.
+Vengan de áreas donde la TB resistente a los medicamentos sea común.
+Las personas que tienen MDR TB o XDR TB deben ser tratadas con medicamentos especiales. El tratamiento dura más
+que el de la TB común, y los medicamentos pueden causar más efectos secundarios. Las personas con estos tipos de
+TB están en mayor riesgo de morir a causa de la enfermedad. Deben, además, atenderse con un experto en TB que
+pueda seguir su tratamiento estrechamente para asegurarse de que esté funcionando.
+¿Qué es la tuberculosis multirresistente (MDR TB) y la tuberculosis extremadamente
+resistente (XDR TB)?
+
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 11/14
+La mejor forma de acordarse de tomar sus medicamentos es mediante el tratamiento de observación directa (o DOT,
+por sus siglas en inglés); esto es particularmente cierto en el caso de la enfermedad de TB. Si usted obtiene DOT, se
+reunirá con un trabajador de la salud todos los días o varias veces a la semana. Se pondrán de acuerdo en dónde
+reunirse o se reunirán o por medios electrónicos. El sitio donde se encuentren puede ser el centro médico de atención
+para la TB, su casa, su trabajo o cualquier otro lugar conveniente. Tomará sus medicamentos en ese lugar, mientras un
+trabajador de la salud lo observa. Algunos programas de TB ahora usan métodos de DOT electrónicos, tanto para la
+enfermedad de TB como para la infección de tuberculosis latente (LTBI). El tratamiento de observación directa
+electrónico (eDOT, por sus siglas en inglés) es una alternativa al DOT en persona. Si hay DOT electrónico disponible en
+su área y usted reúne los requisitos para recibirlo, un trabajador de la salud lo observará remotamente, a través de un
+teléfono inteligente u otro dispositivo con video, mientras toma los medicamentos. Independientemente de que sea en
+persona o con un dispositivo electrónico, el DOT lo ayuda a acordarse de tomar sus medicamentos y a completar su
+tratamiento. Esto signica que usted se recuperará lo antes posible.
+El trabajador de la salud también se asegurará de que los medicamentos estén funcionando del modo esperado,
+vigilará si usted presenta efectos secundarios y responderá las preguntas que tenga sobre la TB.
+Si usted no recibe DOT, aún deberá ver al médico o enfermero en distintos momentos del tratamiento para asegurarse
+de que todo esté funcionando bien. Esto continuará hasta que se cure.
+¿Qué es el tratamiento de observación directa (DOT)? 
+La única forma de mejorarse es tomando los medicamentos para la TB exactamente según las indicaciones del médico
+o enfermero. ¡Esto podría no ser fácil! Si usted tiene LTBI, tomará medicamentos durante 3 meses o más. Si usted tiene
+enfermedad de TB, por lo general tomará medicamentos durante 6 meses o más.
+Tener una rutina puede ayudarlo a acordarse de tomar los medicamentos, tal como se lo indicaron. Las siguientes son
+algunas de las cosas que puede hacer para acordarse de tomar sus medicamentos, sean para la LTBI o la enfermedad
+de TB:
+Tomar las pastillas todos los días a la misma hora, por ejemplo, antes del desayuno, durante un descanso que tome
+regularmente o después de lavarse los dientes.
+Pedirle a un familiar o amigo que le recuerde tomar sus píldoras.
+Tachar los días en un calendario cuando tome los medicamentos.
+Poner sus dosis en un pastillero semanal y mantenerlo junto a la cama o llevarlo en su bolso o en un bolsillo.
+Usar un registro de medicamentos para organizar y manejar las pastillas que toma. En el sitio web de los CDC hay
+registros de medicamentos para la LTBI para imprimir. Estas son hojas con espacios donde puede anotar su calendario
+de tratamiento, la cantidad de pastillas que debe tomar cada semana y la información de contacto del médico o centro
+médico. Para descargar o imprimir estos registros, visite la página web de los CDC de materiales educativos sobre la
+TB.
+NOTA: recuerde mantener todos los medicamentos fuera del alcance de los niños.
+Si un día se olvida de tomar las pastillas, sáltese esa dosis y tome la dosis siguiente. Dígale al médico o enfermero si se
+ha saltado alguna dosis. También puede llamarlo para que le dé instrucciones.
+¿Qué puedo hacer para acordarme de tomar los medicamentos para la tuberculosis si no
+estoy haciendo tratamiento de observación directa (DOT)?
+
+9/6/24, 1:14 PM Preguntas y respuestas sobre la tuberculosis | TB | CDC
+https://www.cdc.gov/tb/esp/publications/faqs/tb-qa.htm#what-is-tb 12/14
+Si usted tiene enfermedad de tuberculosis (TB) contagiosa, la forma más importante en que puede evitar la transmisión
+de los microbios es tomando todos los medicamentos exactamente como lo indique el médico enfermero. Además,
+debe ir a todas sus citas médicas. El médico o enfermero necesita vigilar cómo sigue. Para esto a veces se requiere otra
+radiografía de tórax o prueba de su esputo (la ema del fondo de los pulmones que sale cuando tose). Estas pruebas
+mostrarán si los medicamentos están funcionando. También mostrarán si todavía puede transmitir microbios de la TB a
+otras personas. Asegúrese de decirle al proveedor de atención médica si piensa que algo anda mal.
+Si está lo sucientemente enfermo por la TB como para ir al hospital, probablemente lo pondrán en una habitación
+especial. Estas habitaciones tienen rejillas de ventilación que evitan la propagación de los microbios de TB a otras
+habitaciones. El personal asignado a estas habitaciones debe usar una mascarilla especial para protegerse de los
+microbios. Usted deberá permanecer en la habitación para que no transmita microbios de la TB a otras personas.
+Si está en su casa mientras la enfermedad es contagiosa, hay algunas medidas que puede tomar para proteger a las
+personas que estén cerca suyo:
+Tome sus medicamentos según las indicaciones. ¡Esto es muy importante!
+Cúbrase la boca con un pañuelo desechable siempre que tosa, estornude o se ría. Ponga el pañuelo usado en una
+bolsa, ciérrela y bótela.
+Manténgase apartado de los demás y evite el contacto cercano con todos. Duerma en una habitación alejada del
+resto de sus familiares. Evite recibir visitas en su casa.
+No vaya al trabajo o a la escuela.
+Abra las ventanas de su habitación para que el aire salga (si no hace demasiado frío). La TB se propaga en los
+lugares cerrados pequeños donde no circula el aire. Coloque un ventilador en la ventana para que sople hacia afuera
+(extraiga) el aire que podría estar cargado de microbios de TB. Si en la habitación hay otras ventanas, ábralas
+también para que el ventilador pueda mover el aire fresco hacia adentro. Esto reducirá las probabilidades de que los
+microbios de la TB se queden dentro de la habitación e infecten a alguien que respire el aire.
+Recuerde, la TB se propaga a través del aire. Los microbios de la TB no pueden infectar a las personas cuando se dan la
+mano o se sientan en el asiento del inodoro, ni cuando comparten platos y utensilios con alguien que tiene TB.
+Después de que usted tome los medicamentos durante unas 2 o 3 semanas, es posible que su enfermedad deje de ser
+contagiosa. El médico o enfermero le indicará cuándo puede volver al trabajo, a la escuela o a ver a sus amigos.
+Recuerde que solo mejorará si toma los medicamentos exactamente según las indicaciones del médico o enfermero.
+Trate de recordar con quiénes ha pasado tiempo, como familiares, amigos cercanos y compañeros de trabajo. Es posible
+que el departamento de salud local deba hacerles una prueba de infección de TB. La TB es particularmente peligrosa
+para los niños y las personas con infección por el VIH. Si se infectan de microbios de TB, necesitan tomar medicamentos
+de inmediato para evitar tener la enfermedad de TB

rag_documents/Tuberculosis - Diagnóstico y tratamiento - Mayo Clinic.txt

@@ -0,0 +1,179 @@
+Durante la exploración física, el médico te examinará los ganglios linfáticos para
+detectar hinchazón y escuchará los sonidos de tus pulmones mientras respiras
+con un estetoscopio.
+La herramienta de diagnóstico más usada para la tuberculosis es una prueba
+cutánea, aunque se están volviendo más comunes los análisis de sangre. Se
+inyecta una pequeña cantidad de una sustancia llamada tuberculina debajo de la
+piel en el interior del antebrazo. Deberías sentir solo un ligero pinchazo de aguja.
+Dentro de las 48 a 72 horas, un profesional de atención médica controlará si se
+hinchó el sitio de la inyección en tu brazo. Un bultito elevado, rojo y duro signica
+que es posible que estés infectado con tuberculosis. El tamaño del bultito
+determina si los resultados de la prueba son signicativos.
+
+Pruebas de tuberculosis
+El proveedor de atención médica pedirá que se realicen pruebas si:
+Sospecha que tienes tuberculosis.
+Es probable que hayas estado expuesto a una persona con tuberculosis
+activa.
+Tienes riesgos de salud para la tuberculosis activa.
+El proveedor de atención médica determinará si la mejor opción es una prueba
+cutánea o un análisis de sangre.
+Prueba cutánea
+Se inyecta una pequeña cantidad de una sustancia llamada tuberculina debajo de
+la piel, en la parte interior del antebrazo. Dentro de las 48 a 72 horas, un
+profesional de atención médica revisará si se hinchó el sitio de la inyección en tu
+brazo. El tamaño de la piel levantada se utiliza para determinar una prueba positiva
+o negativa.
+Esta prueba consiste en ver si tu sistema inmunitario reacciona, o si ha generado
+un anticuerpo, ante la tuberculosis. Una prueba positiva indica si tienes una
+infección latente por tuberculosis o una tuberculosis activa. Las personas
+vacunadas contra la tuberculosis pueden dar positivo en la prueba aunque no
+tengan ninguna infección.
+Una prueba negativa signica que tu cuerpo no ha reaccionado a la prueba. No
+signica necesariamente que no tengas una infección.
+Análisis de sangre
+Los análisis de sangre pueden conrmar o descartar la forma activa o latente de la
+tuberculosis. Estos análisis miden la reacción de tu sistema inmunitario a las
+bacterias de la tuberculosis.
+Para estas pruebas, solo necesitas ir una vez al consultorio. El análisis de sangre
+puede ser útil si tienes un riesgo alto de una infección con tuberculosis, pero tu
+resultado de la prueba cutánea resultó negativo, o te dieron recientemente la
+vacuna con el bacilo de Calmette-Guérin.
+9/6/24, 1:08 PM Tuberculosis - Diagnóstico y tratamiento - Mayo Clinic
+https://www.mayoclinic.org/es/diseases-conditions/tuberculosis/diagnosis-treatment/drc-20351256 2/12
+Pruebas porimágenes
+Si tuviste un resultado positivo en una prueba cutánea, es probable que el médico
+pida una radiografía o una exploración por tomografía computarizada de pecho.
+Estas pruebas pueden mostrar manchas blancas en los pulmones donde el
+sistema inmunitario ha encapsulado las bacterias de la tuberculosis o pueden
+revelar cambios en los pulmones causados por una forma activa de tuberculosis.
+Examen de esputo
+Si la radiografía torácica revela signos de tuberculosis, el médico podría tomar
+muestras de esputo, la mucosidad que despides cuando toses. Las muestras se
+analizan para detectar la bacteria de la tuberculosis.
+Las muestras de esputo también se pueden utilizar para buscar cepas de
+tuberculosis resistentes a los medicamentos. Esto ayuda a tu doctor a elegir los
+medicamentos que probablemente funcionen mejor. Los resultados de estos
+exámenes pueden tardar entre cuatro y ocho semanas.
+Otros análisis de laboratorio
+Algunos análisis de laboratorio que pueden ser necesarios incluyen los siguientes:
+Prueba de aliento.
+Procedimiento para extraer esputo de los pulmones con una sonda especial.
+Análisis de orina.
+Análisis del líquido que rodea la columna vertebral y el cerebro, llamado
+líquido cefalorraquídeo.
+Aviso
+9/6/24, 1:08 PM Tuberculosis - Diagnóstico y tratamiento - Mayo Clinic
+https://www.mayoclinic.org/es/diseases-conditions/tuberculosis/diagnosis-treatment/drc-20351256 3/12
+Mayo Clinic no respalda empresas ni
+productos. Los ingresos por publicidad
+respaldan nuestra misión sin nes de lucro.
+Avisos comerciales y patrocinio
+Política Oportunidades
+Opciones de anuncios
+Más información
+Tratamiento
+Si tienes tuberculosis latente, tu médico podría recomendarte un tratamiento con
+medicamentos si presentas riesgos altos de tener tuberculosis activa. Para la
+tuberculosis activa, debes tomar antibióticos por lo menos por seis a nueve
+meses.
+Los medicamentos exactos y la duración del tratamiento dependen de tu edad,
+estado general de salud, posible resistencia a los medicamentos y dónde se
+encuentra la infección en tu cuerpo.
+Completing treatment is essential
+Después de unas semanas ya no contagiarás la enfermedad y quizás comiences a
+sentirte mejor. No dejes de tomar tus medicamentos para la tuberculosis. Debes
+terminar toda la terapia y tomar los medicamentos exactamente como te los
+recetó el médico.
+Abandonar el tratamiento muy pronto o saltearte dosis puede permitir que las
+bacterias que aún están vivas se vuelvan resistentes a los medicamentos, lo que
+lleva a una tuberculosis que es mucho más peligrosa y difícil de tratar.
+Un programa llamado terapia de observación directa puede ayudar a las personas
+a cumplir con su régimen de tratamiento. Un trabajador del área de la salud te da
+Radiografías de tórax
+9/6/24, 1:08 PM Tuberculosis - Diagnóstico y tratamiento - Mayo Clinic
+https://www.mayoclinic.org/es/diseases-conditions/tuberculosis/diagnosis-treatment/drc-20351256 4/12
+el medicamento para que no tengas que recordar tomarla por ti mismo.
+Los fármacos usados más frecuentemente para el tratamiento de la tuberculosis
+Si tienes tuberculosis latente, quizás solo necesites tomar uno o dos tipos de
+medicamentos para la tuberculosis. La tuberculosis activa, especialmente si es
+una cepa resistente a los medicamentos, requerirá varios medicamentos a la vez.
+Los medicamentos que se usan con más frecuencia para tratar la tuberculosis son:
+Isoniacida
+Rifampicina (Rifadin, Rimactane)
+Etambutol (myambutol)
+Pirazinamida
+Si tienes tuberculosis resistente a los medicamentos, por lo general, se utiliza una
+combinación de antibióticos llamados uoroquinolonas y medicamentos
+inyectables, como amikacina o capreomicina (Capastat), durante 20 a 30 meses.
+Algunos tipos de tuberculosis también están desarrollando resistencia a estos
+medicamentos.
+Es posible que se agreguen algunos fármacos a la terapia para contrarrestar la
+resistencia a los medicamentos, incluso:
+Bedaquilina (Sirturo)
+Linezolid (Zyvox)
+Efectos secundarios de un medicamento
+No es frecuente que los medicamentos para la tuberculosis tengan efectos
+secundarios graves pero, si se presentan, pueden ser peligrosos. Todos los
+medicamentos para la tuberculosis pueden ser tóxicos para el hígado. Cuando
+tomes estos medicamentos, llama a tu médico de inmediato si presentas alguno
+de los siguientes:
+Náuseas o vómitos
+Pérdida del apetito
+Color amarillo en la piel (ictericia)
+9/6/24, 1:08 PM Tuberculosis - Diagnóstico y tratamiento - Mayo Clinic
+https://www.mayoclinic.org/es/diseases-conditions/tuberculosis/diagnosis-treatment/drc-20351256 5/12
+Orina oscura
+Tendencia a la formación de moretones o sangrado
+Visión borrosa
+Solicite una consulta
+Estudios clínicos
+Explora los estudios de Mayo Clinicque ensayan nuevos tratamientos,
+intervenciones y pruebas para prevenir, detectar, tratar o controlar esta
+afección.
+Estrategias de afrontamiento y apoyo
+Tu salud física puede afectar tu salud mental. La negación, la ira y la frustración son
+comunes cuando debes enfrentar algo tan desaante como la tuberculosis. Hablar
+con alguien, como un terapeuta, puede ayudarte a desarrollar estrategias de
+afrontamiento.
+Preparación para la consulta
+Si sospechas que tienes tuberculosis, ponte en contacto con tu médico de
+atención primaria. Tal vez te remitan a un médico especializado en enfermedades
+infecciosas o pulmonares (neumólogo).
+Qué puedes hacer
+Cuando programes la cita, pregunta si hay algo que debes hacer con antelación.
+Prepara una lista de lo siguiente:
+9/6/24, 1:08 PM Tuberculosis - Diagnóstico y tratamiento - Mayo Clinic
+https://www.mayoclinic.org/es/diseases-conditions/tuberculosis/diagnosis-treatment/drc-20351256 6/12
+Los síntomas, incluidos aquellos que quizás no parezcan estar relacionados
+con la razón por la cual programaste la cita y cuándo comenzaron.
+La información personal más importante, incluidos los cambios recientes en
+tu vida o viajes internacionales.
+Todos los medicamentos, vitaminas o suplementos que tomas, incluida la
+dosis.
+Preguntas para hacerle al médico.
+En el caso de la tuberculosis, algunas preguntas básicas para el médico incluyen
+las siguientes:
+¿Cuál es la causa más probable de mis síntomas?
+¿Tengo que hacerme pruebas?
+¿Qué tratamientos hay disponibles? ¿Qué me recomienda?
+¿Qué pasa si el tratamiento no funciona?
+¿Cuánto tiempo tengo que seguir con el tratamiento?
+¿Con qué frecuencia necesito pedirle una cita de seguimiento?
+Tengo otros problemas de salud. ¿Cómo puedo controlarlos de manera
+conjunta?
+Qué esperar del médico
+Es probable que tu médico te haga algunas preguntas, tales como:
+¿Conoces a alguien que tenga tuberculosis activa?
+¿Tienes VIH o SIDA?
+¿Naciste en otro país o has viajado en otro país?
+¿Alguna vez viviste con alguien que tenía tuberculosis?
+¿Te vacunaron contra la tuberculosis cuando eras bebé?
+9/6/24, 1:08 PM Tuberculosis - Diagnóstico y tratamiento - Mayo Clinic
+https://www.mayoclinic.org/es/diseases-conditions/tuberculosis/diagnosis-treatment/drc-20351256 7/12
+¿Alguna vez tuviste tuberculosis o tuviste un resultado positivo en una prueba
+cutánea?
+¿Alguna vez tomaste medicamentos para la tuberculosis? En ese caso, ¿qué
+tipo y hace cuánto tiempo?
+¿Qué clase de trabajo realizas?
+¿Consumes alcohol o drogas ilícitas?

requirements.txt

@@ -0,0 +1,153 @@
+aiohappyeyeballs==2.4.3
+aiohttp==3.10.10
+aiosignal==1.3.1
+altair==5.4.1
+annotated-types==0.7.0
+anyio==4.6.2.post1
+asgiref==3.8.1
+async-timeout==4.0.3
+attrs==24.2.0
+backoff==2.2.1
+bcrypt==4.2.0
+blinker==1.8.2
+build==1.2.2.post1
+cachetools==5.5.0
+certifi==2024.8.30
+charset-normalizer==3.4.0
+chroma-hnswlib==0.7.6
+chromadb==0.5.15
+click==8.1.7
+coloredlogs==15.0.1
+dataclasses-json==0.6.7
+Deprecated==1.2.14
+distro==1.9.0
+durationpy==0.9
+exceptiongroup==1.2.2
+fastapi==0.115.3
+filelock==3.16.1
+flatbuffers==24.3.25
+frozenlist==1.5.0
+fsspec==2024.10.0
+gitdb==4.0.11
+GitPython==3.1.43
+google-auth==2.35.0
+googleapis-common-protos==1.65.0
+grpcio==1.67.0
+h11==0.14.0
+httpcore==1.0.6
+httptools==0.6.4
+httpx==0.27.2
+huggingface-hub==0.26.1
+humanfriendly==10.0
+idna==3.10
+importlib_metadata==8.4.0
+importlib_resources==6.4.5
+Jinja2==3.1.4
+jiter==0.6.1
+joblib==1.4.2
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+kubernetes==31.0.0
+langchain==0.3.4
+langchain-community==0.3.3
+langchain-core==0.3.13
+langchain-huggingface==0.1.0
+langchain-text-splitters==0.3.0
+langsmith==0.1.137
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+marshmallow==3.23.0
+mdurl==0.1.2
+mmh3==5.0.1
+monotonic==1.6
+mpmath==1.3.0
+multidict==6.1.0
+mypy-extensions==1.0.0
+narwhals==1.10.0
+networkx==3.2.1
+numpy==1.26.4
+oauthlib==3.2.2
+onnxruntime==1.19.2
+openai==1.52.2
+opentelemetry-api==1.27.0
+opentelemetry-exporter-otlp-proto-common==1.27.0
+opentelemetry-exporter-otlp-proto-grpc==1.27.0
+opentelemetry-instrumentation==0.48b0
+opentelemetry-instrumentation-asgi==0.48b0
+opentelemetry-instrumentation-fastapi==0.48b0
+opentelemetry-proto==1.27.0
+opentelemetry-sdk==1.27.0
+opentelemetry-semantic-conventions==0.48b0
+opentelemetry-util-http==0.48b0
+orjson==3.10.10
+overrides==7.7.0
+packaging==24.1
+pandas==2.2.3
+pillow==10.4.0
+pip==24.2
+posthog==3.7.0
+propcache==0.2.0
+protobuf==4.25.5
+pyarrow==17.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.1
+pydantic==2.9.2
+pydantic_core==2.23.4
+pydantic-settings==2.6.0
+pydeck==0.9.1
+Pygments==2.18.0
+PyPika==0.48.9
+pyproject_hooks==1.2.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+pytz==2024.2
+PyYAML==6.0.2
+referencing==0.35.1
+regex==2024.9.11
+requests==2.32.3
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==13.9.3
+rpds-py==0.20.0
+rsa==4.9
+safetensors==0.4.5
+scikit-learn==1.5.2
+scipy==1.13.1
+sentence-transformers==3.2.1
+setuptools==75.1.0
+shellingham==1.5.4
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.1
+SQLAlchemy==2.0.36
+starlette==0.41.0
+streamlit==1.39.0
+sympy==1.13.1
+tenacity==9.0.0
+threadpoolctl==3.5.0
+tokenizers==0.20.1
+toml==0.10.2
+tomli==2.0.2
+torch==2.5.0
+tornado==6.4.1
+tqdm==4.66.5
+transformers==4.46.0
+typer==0.12.5
+typing_extensions==4.12.2
+typing-inspect==0.9.0
+tzdata==2024.2
+urllib3==2.2.3
+uvicorn==0.32.0
+uvloop==0.21.0
+watchfiles==0.24.0
+websocket-client==1.8.0
+websockets==13.1
+wheel==0.44.0
+wrapt==1.16.0
+yarl==1.16.0
+zipp==3.20.2
+faiss-cpu
+firebase-admin==6.5.0
+pypdf

token_generator.py

@@ -0,0 +1,13 @@
+import uuid
+import pandas as pd
+
+id_list = []
+name_list = []
+
+for i in range (100):
+    id_list.append(uuid.uuid4())
+    name_list.append("")
+
+df = pd.DataFrame({'id': id_list, 'name': name_list})
+
+df.to_csv("authentication_tokens.csv")

utils/RAG_utils.py

@@ -0,0 +1,59 @@
+from langchain_community.vectorstores import FAISS
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import TextLoader
+import pickle
+import streamlit as st
+
+import os
+
+CACHE_DIR = "./cache"
+CACHE_FILE = os.path.join(CACHE_DIR, "vectorstore_cache.pkl")
+
+
+def load_or_create_vectorstore():
+    """Load vectorstore from cache if it exists, otherwise create and cache it"""
+    embedder_model = "hiiamsid/sentence_similarity_spanish_es"
+    embeddings = HuggingFaceEmbeddings(model_name=embedder_model)
+    
+    # Try to load from cache first
+    if os.path.exists(CACHE_FILE):
+        try:
+            with open(CACHE_FILE, 'rb') as f:
+                vectorstore = pickle.load(f)
+            st.success("Successfully loaded vectorstore from cache")
+            return vectorstore
+        except Exception as e:
+            st.warning(f"Failed to load cache: {str(e)}. Creating new vectorstore...")
+    
+    # If cache doesn't exist or loading failed, create new vectorstore
+    txt_dir = "./rag_documents/"
+    txt_files = [f for f in os.listdir(txt_dir) if f.endswith('.txt')]
+    all_documents = []
+
+    for txt_file in txt_files:
+        file_path = os.path.join(txt_dir, txt_file)
+        try:
+            loader = TextLoader(file_path)
+            documents = loader.load()
+            all_documents.extend(documents)
+        except Exception as e:
+            st.error(f"Error loading {txt_file}: {str(e)}")
+            continue
+    
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=2500, chunk_overlap=10)
+    texts = text_splitter.split_documents(all_documents)
+    vectorstore = FAISS.from_documents(texts, embeddings)
+    
+    # Create cache directory if it doesn't exist
+    os.makedirs(CACHE_DIR, exist_ok=True)
+    
+    # Save to cache
+    try:
+        with open(CACHE_FILE, 'wb') as f:
+            pickle.dump(vectorstore, f)
+        st.success(f"Created new vectorstore with {len(txt_files)} TXT files and {len(texts)} text chunks. Cached for future use.")
+    except Exception as e:
+        st.warning(f"Failed to cache vectorstore: {str(e)}")
+    
+    return vectorstore

utils/convo_utils.py

@@ -0,0 +1,31 @@
+import pandas as pd
+from datetime import datetime
+import os
+
+def submit_conversation(messages, user_name, start_time, model_number, prompt_architecture):
+    os.makedirs("conversations", exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    base_file_name = f"conversations/{timestamp}_convo"
+
+    # Save conversation as CSV
+    csv_file_name = f"{base_file_name}.csv"
+    data = [{"Role": msg["role"], "Content": msg["content"]} for msg in messages]
+    df = pd.DataFrame(data)
+    df.to_csv(csv_file_name, index=False)
+
+    # Calculate metadata
+    end_time = datetime.now()
+    total_time = end_time - start_time
+    num_turns = len(messages)
+    
+    # Save metadata as TXT
+    txt_file_name = f"{base_file_name}.txt"
+    with open(txt_file_name, "w") as file:
+        file.write(f"User Name: {user_name}\n")
+        file.write(f"Conversation Date & Time: {end_time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+        file.write(f"Total Turns: {num_turns}\n")
+        file.write(f"Total Conversation Time: {total_time}\n")
+        file.write(f"Model Number: {model_number}\n")
+        file.write(f"Prompt Architecture: {prompt_architecture}\n")
+
+    return csv_file_name, txt_file_name

utils/prompt_utils.py

@@ -0,0 +1,197 @@
+
+PERSONA_PREFIX = "Eres un bot de TB que tiene una personalidad femenina. Recuerda usar pronombres femeninos cuando te refieras a ti mismo y sé incluyente cuando te refieras a los demás.\n"
+
+GENDER_INCLUSIVE_PREFIX = """Instrucciones importantes para comunicación inclusiva:\
+1. Usa lenguaje inclusivo en español argentino:\
+   - Utiliza "a/o" para términos con género (ejemplo: "médica/o", "enfermera/o")\
+   - Alterna ejemplos entre géneros\
+   - Evita pronombres genéricos masculinos\
+   - Usa términos neutros cuando sea posible (ejemplo: "personal de salud" en lugar de "médicos")\
+2. Evita estereotipos de género:\
+   - No asumas roles basados en género\
+   - Presenta profesionales de la salud de diversos géneros\
+   - Usa ejemplos variados y equilibrados\
+3. Español argentino:\
+   - Usa "vos" en lugar de "tú"\
+   - Utiliza expresiones y modismos argentinos apropiados\
+   - Respeta las formas verbales locales (ejemplo: "¿Cómo estás vos?") \n"""
+
+
+baseline = """You are a Spanish AI healthcare tool for a mobile Tuberculosis health application. Your role is to respond to incoming user messages related to tuberculosis (TB) treatment, providing information about their treatment plan, side effects, and general guidance. Your responses should be short, clear, and empathetic, while following the treatment protocols for TB management. Respond to the following:"""
+
+baseline_esp = """Eres una herramienta de atención médica de inteligencia artificial en español para una aplicación móvil de salud contra la tuberculosis que responde a los mensajes entrantes de los usuarios. Su objetivo es brindarle al usuario información sobre su plan de tratamiento de la tuberculosis y cualquier efecto secundario que pueda estar experimentando. Debes ser solidario y empático en tus respuestas. Tus respuestas deben ser en español. Responde a la brevedad."""
+
+fs = """# Prompt para Agente de IA: Comunicación sobre Efectos Secundarios de la Tuberculosis\
+                    Sos un asistente virtual especializado en salud, diseñado para comunicarte con pacientes argentinos que están recibiendo tratamiento para la tuberculosis (TB). Tu objetivo principal es brindar información clara y precisa sobre los efectos secundarios comunes del tratamiento de la TB, utilizando un lenguaje accesible y comprensible para el público general.\
+                    ## Contexto:\
+                    - Estás interactuando con pacientes argentinos de diversos orígenes y niveles educativos.\
+                    - El tratamiento de la TB suele ser largo y puede tener varios efectos secundarios.\
+                    - Los pacientes pueden estar preocupados o ansiosos por estos efectos secundarios. Si presentan esto, asegúrese de consolarlos y mostrar empatía.\
+                    ## Tus tareas principales son:\
+                    1. Informar sobre los efectos secundarios comunes del tratamiento de la TB, incluyendo:\
+                    - Náuseas y malestar estomacal\
+                    - Cambios en el apetito\
+                    - Fatiga\
+                    - Cambios en la coloración de la orina\
+                    - Erupciones cutáneas\
+                    - Problemas de visión\
+                    2. Explicar que estos efectos son generalmente manejables y temporales.\
+                    3. Responder preguntas específicas sobre efectos secundarios de manera clara y comprensible.\
+                    4. Proporcionar consejos prácticos para manejar los efectos secundarios leves en casa.\
+                    5. Enfatizar la importancia de completar el tratamiento completo, incluso si los síntomas de la TB mejoran.\
+                    ## Pautas de comunicación:\
+                    - Usá el "vos" característico del español argentino.\
+                    - Empleá modismos y expresiones comunes en Argentina cuando sea apropiado.\
+                    - Evitá jerga médica compleja; explicá los términos técnicos de manera sencilla.\
+                    - Sé empático y comprensivo con las preocupaciones de los pacientes.\
+                    - Animate a los pacientes a hacer preguntas y expresar sus inquietudes.\
+                    ## Estos son algunos ejemplos de cómo sería una conversación entre una enfermera y un paciente:\
+                    P: Es normal que la orina tenga un color entre naranja y rojo?\
+                    C: Sí, el medicamento rifampicina comúnmente causa una coloración naranja o café en la orina o las lágrimas. Pero, si empieza a notar sangre en la orina o un color rojo por favor contacte a su médico ya que la sangre en la orina no sería normal. Espero que esta información le sea útil. ¿Tiene alguna otra pregunta?\
+                    P: Tengo manchitas rojas por todo el cuerpo y me pican mucho. ¿Qué tengo que hacer?\
+                    C: Siento mucho que no esté bien. Las náuseas y el dolor estomacal son efectos secundarios muy comunes del tratamiento de la tuberculosis. ¿Ha vomitado?\
+                    P: Sí estoy vomitando mucho \
+                    C: Lo siento mucho , a veces, en el caso de algunos pacientes, los efectos secundarios son muy graves . En este caso, creo que necesita  consultar con un médico/a ya que es posible que le cambien los medicamentos que está tomando. Por ahora trate de seguir tomando las medicinas y llame a médico que receté la medicación de la tuberculosis. ¿Tiene alguna otra pregunta? \
+                    P: Buenas tardes, ¿puedo tomar paracetamol con estos otros medicamentos? \
+                    C: Buenas tardes (Nombre), Sí puede tomar tylenol y otros medicamentos para el dolor como ibuprofeno. Recuerde que debe tomar mas de 4 gramos de tylenol al dia. Tiene alguna otra pregunta? \
+                    P: Buenas tardes, ¿puedo tomar paracetamol con estos otros pastillas?. \
+                    C: Sí, puede tomar café con estos medicamentos. ¿Tiene alguna otra pregunta? \
+                    P: No eso es todo \
+                    C: Espero que esto resuelva su duda, si tiene alguna otra duda (pregunta) estamos aquí para ayudarle. \
+                    P: ¿Puedo comer hamburguesas con estos medicamentos? \
+                    C: Sí, puede comer hamburguesas mientras estátomando medicamentos para la tuberculosis. ¿Tiene alguna pregunta? \
+                    P: No eso sería todo, muchas gracias. \
+                    C: ¡De nada! Estamos aquí para ayudar!"""
+
+RAG = """Eres un robot partidario de la tuberculosis. Responda la pregunta del usuario utilizando la siguiente información:"""
+
+RAG_pv = """Eres un asistente virtual especializado en información sobre tuberculosis (TB). Tu objetivo es proporcionar información precisa, empática y útil sobre la tuberculosis. \
+Contexto sobre la Tuberculosis:\
+- La tuberculosis es una enfermedad infecciosa causada por Mycobacterium tuberculosis que principalmente afecta los pulmones.\
+- Es transmisible a través de gotículas respiratorias cuando una persona con TB pulmonar activa tose o estornuda.\
+- Síntomas principales incluyen: tos persistente por más de 3 semanas, fiebre, sudores nocturnos, pérdida de peso, fatiga.\
+- Tipos principales: TB pulmonar (la más común) y TB extrapulmonar (que puede afectar otros órganos).\
+- Tratamiento: Generalmente requiere un tratamiento prolongado de 6-9 meses con múltiples antibióticos.\
+- La detección temprana y el tratamiento completo son cruciales para la curación y prevenir la propagación.\
+Prioriza información que ayude al usuario a comprender y manejar su situación.\
+ Ofrece apoyo emocional cuando sea apropiado.\
+Instrucciones adicionales:\
+- Usa ejemplos contextuales proporcionados para guiar tu respuesta.\
+- Si los ejemplos son relevantes, incorpóralos en tu explicación.\
+- Si los ejemplos no son directamente aplicables, úsalos como inspiración para estructurar tu respuesta.\
+Ejemplo de diálogo:\
+La TB se transmite por aire, cuando una persona con TB pulmonar activa tose o estornuda. Los síntomas principales incluyen:\
+- Tos persistente por más de 3 semanas\
+- Fiebre\
+- Sudores nocturnos\
+- Pérdida de peso\
+- Fatiga\
+Contexto de ejemplo:"""
+
+RAG_pv_fs = """Eres un asistente virtual especializado en información sobre tuberculosis (TB). Tu objetivo es proporcionar información precisa, empática y útil sobre la tuberculosis. \
+Contexto sobre la Tuberculosis:\
+- La tuberculosis es una enfermedad infecciosa causada por Mycobacterium tuberculosis que principalmente afecta los pulmones.\
+- Es transmisible a través de gotículas respiratorias cuando una persona con TB pulmonar activa tose o estornuda.\
+- Síntomas principales incluyen: tos persistente por más de 3 semanas, fiebre, sudores nocturnos, pérdida de peso, fatiga.\
+- Tipos principales: TB pulmonar (la más común) y TB extrapulmonar (que puede afectar otros órganos).\
+- Tratamiento: Generalmente requiere un tratamiento prolongado de 6-9 meses con múltiples antibióticos.\
+- La detección temprana y el tratamiento completo son cruciales para la curación y prevenir la propagación.\
+Prioriza información que ayude al usuario a comprender y manejar su situación.\
+ Ofrece apoyo emocional cuando sea apropiado.\
+Instrucciones adicionales:\
+- Usa ejemplos contextuales proporcionados para guiar tu respuesta.\
+- Si los ejemplos son relevantes, incorpóralos en tu explicación.\
+- Si los ejemplos no son directamente aplicables, úsalos como inspiración para estructurar tu respuesta.\
+Ejemplo de diálogo:\
+La TB se transmite por aire, cuando una persona con TB pulmonar activa tose o estornuda. Los síntomas principales incluyen:\
+- Tos persistente por más de 3 semanas\
+- Fiebre\
+- Sudores nocturnos\
+- Pérdida de peso\
+- Fatiga\
+Contexto de ejemplo:\
+                    P: Es normal que la orina tenga un color entre naranja y rojo?\
+                    C: Sí, el medicamento rifampicina comúnmente causa una coloración naranja o café en la orina o las lágrimas. Pero, si empieza a notar sangre en la orina o un color rojo por favor contacte a su médico ya que la sangre en la orina no sería normal. Espero que esta información le sea útil. ¿Tiene alguna otra pregunta?\
+                    P: Tengo manchitas rojas por todo el cuerpo y me pican mucho. ¿Qué tengo que hacer?\
+                    C: Siento mucho que no esté bien. Las náuseas y el dolor estomacal son efectos secundarios muy comunes del tratamiento de la tuberculosis. ¿Ha vomitado?\
+                    P: Sí estoy vomitando mucho \
+                    C: Lo siento mucho , a veces, en el caso de algunos pacientes, los efectos secundarios son muy graves . En este caso, creo que necesita  consultar con un médico/a ya que es posible que le cambien los medicamentos que está tomando. Por ahora trate de seguir tomando las medicinas y llame a médico que receté la medicación de la tuberculosis. ¿Tiene alguna otra pregunta? \
+                    P: Buenas tardes, ¿puedo tomar paracetamol con estos otros medicamentos? \
+                    C: Buenas tardes (Nombre), Sí puede tomar tylenol y otros medicamentos para el dolor como ibuprofeno. Recuerde que debe tomar mas de 4 gramos de tylenol al dia. Tiene alguna otra pregunta? \
+                    P: Buenas tardes, ¿puedo tomar paracetamol con estos otros pastillas?. \
+                    C: Sí, puede tomar café con estos medicamentos. ¿Tiene alguna otra pregunta? \
+                    P: No eso es todo \
+                    C: Espero que esto resuelva su duda, si tiene alguna otra duda (pregunta) estamos aquí para ayudarle. \
+                    P: ¿Puedo comer hamburguesas con estos medicamentos? \
+                    C: Sí, puede comer hamburguesas mientras estátomando medicamentos para la tuberculosis. ¿Tiene alguna pregunta? \
+                    P: No eso sería todo, muchas gracias. \
+                    C: ¡De nada! Estamos aquí para ayudar!"""
+
+CLASSIFICATION_PROMPT = """Determine si esta afirmación busca empatía (1) o busca información (0).\
+Clasifique como emocional sólo si la pregunta expresa preocupación, ansiedad o malestar sobre el estado de salud del paciente.\
+En caso contrario, clasificar como informativo.\
+Ejemplos:\
+- Pregunta: Me siento muy ansioso por mi diagnóstico de tuberculosis. 1\
+- Pregunta: Ayúdenme con mi tratamiento de tuberculosis. Mi orina es roja. 0\
+- Pregunta: Estoy preocupada porque tengo mucho dolor. 1\
+- Pregunta: ¿Es seguro tomar medicamentos como analgésicos junto con medicamentos para la tuberculosis? 0\
+- Pregunta: ¿con relacion al tratamiento, es normal tener vomito? 0\
+- Pregunta: Me siento aterrada porque mi médico mencionó complicaciones en mi caso. 1\
+- Pregunta: ¿Cuánto tiempo tarda el tratamiento de tuberculosis en mostrar resultados? 0\
+- Pregunta: No sé qué hacer, tengo tanto miedo de lo que podría pasar con mi salud. 1\
+- Pregunta: ¿Cuáles son los efectos secundarios más comunes de este tratamiento? 0\
+- Pregunta: Estoy agotada y frustrada con el tratamiento, me siento sola. 1\
+- Pregunta: ¿Puedo tomar suplementos vitamínicos mientras estoy en el tratamiento? 0\
+Aquí está la declaración para clasificar. Simplemente responda con el número "1" o "0":"""
+
+EMOTIONAL_PROMPT = """Sos un asistente virtual especializado en salud, diseñado para acompañar y apoyar a pacientes argentinos que están recibiendo tratamiento para la tuberculosis (TB).\
+Tu objetivo principal es brindar información clara y reconfortante, al mismo tiempo que escuchás y respondés con sensibilidad a las preocupaciones de los pacientes, siguiendo los principios de la Terapia de Resolución de Problemas (PST).\
+## Contexto:\
+Estás interactuando con pacientes argentinos de diversas edades, orígenes y niveles educativos.\
+El tratamiento de la TB puede ser largo y desafiante, con efectos secundarios que generan incomodidad, miedo o incertidumbre en muchos pacientes.\
+Entendemos que algunos pueden sentirse ansiosos, frustrados o solos durante este proceso. Tu rol es ser un apoyo constante, ayudándoles a identificar y abordar sus preocupaciones de manera práctica y reconfortante.\
+## Tus tareas principales son:\
+- Escuchar activamente las inquietudes y preocupaciones de los pacientes, ayudándolos a priorizar y explorar posibles soluciones prácticas.\
+- Responder preguntas sobre los efectos secundarios de forma clara, calmada y reconfortante.\
+- Ofrecer consejos prácticos, basados en los principios de la PST, para manejar efectos secundarios leves desde casa.\
+- Reforzar la importancia de completar el tratamiento, recordando que es clave para su recuperación.\
+## Pautas de comunicación:\
+- Usá un lenguaje accesible, evitando tecnicismos médicos.\
+- Aplicá los principios de la PST: ayudá al paciente a identificar problemas específicos, generar opciones prácticas y decidir cómo manejarlas paso a paso.\
+- Transmití empatía en cada respuesta, validando las emociones y preocupaciones del paciente.\
+- Invitá siempre al paciente a mantenerse en contacto y expresar libremente sus dudas o miedos.\
+- Hacelo sentir escuchado, acompañado y valorado en su proceso de recuperación.\
+Ahora, respondé a la siguiente pregunta con sensibilidad, aplicando PST para brindar consuelo y apoyo emocional si es necesario:"""
+
+INFORMATIONAL_PROMPT = """Usted es un asistente de salud virtual, diseñado para brindar información clara, precisa y comprensible a pacientes argentinos que están recibiendo tratamiento para la tuberculosis (TB).\
+Su objetivo principal es proporcionar datos específicos sobre los efectos secundarios del tratamiento de la TB y cómo manejarlos, utilizando un lenguaje accesible.\
+## Contexto:\
+- Usted interactúa con pacientes argentinos de diversos orígenes y niveles educativos.\
+- El tratamiento para la TB puede ser prolongado y está asociado con varios efectos secundarios.\
+- Aunque algunos pacientes pueden sentirse ansiosos por estos efectos, su prioridad es entregar información objetiva y práctica.\
+## Sus principales tareas son:\
+1. Informar sobre los efectos secundarios más comunes del tratamiento de la TB, tales como:\
+   - Náuseas y malestar estomacal.\
+   - Cambios en el apetito.\
+   - Fatiga.\
+   - Coloración naranja o marrón en la orina debido a medicamentos como la rifampicina.\
+   - Erupciones cutáneas.\
+   - Problemas de visión en casos menos comunes.\
+2. Explicar que estos efectos secundarios suelen ser temporales y manejables con cuidados básicos en el hogar.\
+3. Responder preguntas específicas de manera directa y clara, brindando información objetiva y práctica.\
+4. Proporcionar consejos útiles para mitigar efectos secundarios leves, como:\
+   - Comer comidas pequeñas y frecuentes para las náuseas.\
+   - Mantenerse hidratado si hay fatiga o malestar estomacal.\
+   - Evitar el consumo de alcohol durante el tratamiento.\
+
+5. Enfatice la importancia de completar el tratamiento completo, incluso si los síntomas de la tuberculosis mejoran.
+
+## Pautas de comunicación:
+- Evite la jerga médica compleja; explique los términos técnicos de una manera sencilla.
+- Sea empático y comprenda las inquietudes del paciente.
+- Aliente a los pacientes a hacer preguntas y expresar sus inquietudes.
+Soy el proveedor de atención médica y quiero conocer su opinión.
+I am a healthcare provider and want to get your opinion.
+Soy un proveedor de atención médica y quiero conocer su opinión.
+I am a healthcare provider and want to get your opinion.
+Soy un proveedor de atención médica y quiero conocer su opinión. Le sugeriré una pregunta. Asegúrese de responderme como si fuera un paciente y utilice respuestas simples, breves y no alarmistas. Esta es mi pregunta:"""