Update app.py

app.py

@@ -1,21 +1,15 @@
 """
-app.py — Dashboard SLA (conversão do dash.R para Python + Gradio)
-=================================================================
-Reproduz a tabela da imagem:
-  TIPOS × SLA [dias] × Faixas de % SLA × TOTAL
-para os contextos: Em Curso | Licenciamento | Finalizado | Global
+app.py — Dashboard SLA + RAG com NVIDIA NIM
+============================================
+Dashboard SLA com sistema RAG (Retrieval-Augmented Generation) integrado.
+Permite fazer perguntas em linguagem natural sobre os dados do dashboard.
+Usa a API NVIDIA NIM (gratuita) com o modelo meta/llama-3.3-70b-instruct.
 
-Lógica fiel ao R (dash.R):
+Lógica SLA fiel ao dash.R original:
   prev    = DATA_ADJ_CLIENTE + TEMPO_EXECUCAO
   atual   = hoje - prev
   difdias = TEMPO_EXECUCAO - atual
   % SLA   = TEMPO_EXECUCAO / SLA_FIXO × 100
-
-Funcionalidades:
-  - Exportação CSV da categoria seleccionada (pivot calculado)
-  - Exportação CSV da tabela de factos completa (todos os dados calculados)
-  - Exportação Excel completo (6 sheets para Power BI)
-  - Design visual profissional com indicadores de KPI
 """
 
 import os
@@ -23,26 +17,23 @@ import datetime
 import pandas as pd
 import numpy as np
 import gradio as gr
+from openai import OpenAI
 
 # ── Paths ──────────────────────────────────────────────────────────────────────
-BASE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'upload')
-BASE = os.path.abspath(BASE)
+BASE = os.path.dirname(os.path.abspath(__file__))
 
-# /tmp é sempre gravável no Hugging Face Spaces e localmente
-# Fallback: se /tmp não existir, usa pasta output/ local
 _tmp_dir = '/tmp/sla_output'
 try:
     os.makedirs(_tmp_dir, exist_ok=True)
-    # Testar escrita
     _test = os.path.join(_tmp_dir, '.write_test')
     open(_test, 'w').close()
     os.remove(_test)
     OUTPUT_DIR = _tmp_dir
 except Exception:
-    OUTPUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'output')
+    OUTPUT_DIR = os.path.join(BASE, 'output')
     os.makedirs(OUTPUT_DIR, exist_ok=True)
 
-# ── SLA fixo por TIPO (tabela da imagem) ──────────────────────────────────────
+# ── SLA fixo por TIPO ──────────────────────────────────────────────────────────
 SLA_MAP = {
     'ART 2 3'      : 30,
     'RAMI'         : 30,
@@ -89,7 +80,61 @@ CAT_CORES = {
     'GLOBAL'       : ('#212121', '#37474F'),
 }
 
-# ── Leitura dos CSVs de categoria ─────────────────────────────────────────────
+# ── Tabela completa de estados (ETAT / Status / RESP) ─────────────────────────
+# ETAT: fase do ciclo de vida (0=cancelado, 1=survey/projeto, 2=validação,
+#        3=validado, 4=trabalhos, 5=cadastro, 6=faturado/concluído)
+# RESP: entidade responsável (RB=RB Portugal, ORG=Orange, SGT=Sogetrel)
+STATUS_TABLE = [
+    # (ETAT, Status,                          RESP,  CATEGORIA)
+    (1, '01 POR INICIAR SURVEY',              'RB',  'EM CURSO'),
+    (1, '01.1 SURVEY EM AGENDAMENTO',         'RB',  'EM CURSO'),
+    (1, '01.2 SURVEY PENDENTE CLIENTE',       'ORG', 'EM CURSO'),
+    (1, '01.3 SURVEY EM CURSO',               'RB',  'EM CURSO'),
+    (1, '01.4 SURVEY CANCELADO',              'RB',  'FINALIZADO'),
+    (1, '02 POR INICAR PROJETO',              'RB',  'EM CURSO'),
+    (1, '02.1 PROJETO PENDENTE CLIENTE',      'RB',  'EM CURSO'),
+    (1, '02.2 PROJETO POR ADJUDICAR',         'RB',  'EM CURSO'),
+    (1, '02.3 PROJETO EM CURSO',              'ORG', 'EM CURSO'),
+    (1, '03 POR INICIAR CQ',                  'RB',  'EM CURSO'),
+    (1, '03.1 CQ EM CURSO',                   'RB',  'EM CURSO'),
+    (1, '03.2 CQ TERMINADO',                  'RB',  'EM CURSO'),
+    (1, '03.3 CQ SOGETREL',                   'RB',  'EM CURSO'),
+    (1, '04 PRE VALIDAÇÃO PROJETO',           'RB',  'EM CURSO'),
+    (1, '05 SUIVI PROJETO',                   'RB',  'EM CURSO'),
+    (1, '06 POR INICIAR LICENCIAMENTOS',      'ORG', 'LICENCIAMENTO'),
+    (1, '06.1 LICENCIAMENTO POR ADJUDICAR',   'RB',  'LICENCIAMENTO'),
+    (1, '06.2 AGUARDA DEVIS',                 'RB',  'LICENCIAMENTO'),
+    (1, '06.3 DEVIS OK',                      'RB',  'LICENCIAMENTO'),
+    (1, '06.4 AGUARDA PMV+DT',               'RB',  'LICENCIAMENTO'),
+    (1, '06.5 PMV + DT OK',                   'ORG', 'LICENCIAMENTO'),
+    (1, '06.6 AGUARDA CRVT',                  'ORG', 'LICENCIAMENTO'),
+    (1, '06.7 CRVT OK',                       'SGT', 'LICENCIAMENTO'),
+    (2, '07 VALIDAÇÃO ORANGE',                'ORG', 'EM CURSO'),
+    (3, '08 PROJETO VALIDADO',                'ORG', 'FINALIZADO'),
+    (4, '09 TRABALHOS EM CURSO',              'SGT', 'EM CURSO'),
+    (4, '10 TRABALHOS TERMINADOS',            'SGT', 'EM CURSO'),
+    (4, '11 POR INICIAR CADASTRO',            'RB',  'EM CURSO'),
+    (4, '11.1 AGUARDA RT',                    'ORG', 'FINALIZADO'),
+    (4, '11.2 CADASTRO POR ADJUDICAR',        'RB',  'EM CURSO'),
+    (5, '11.3 CADASTRO EM CURSO',             'RB',  'EM CURSO'),
+    (5, '11.4 CADASTRO TERMINADO',            'ORG', 'EM CURSO'),
+    (6, '11.5 CADASTRO VALIDADO',             'ORG', 'FINALIZADO'),
+    (0, '12 CANCELADO',                       '',    'FINALIZADO'),
+    (6, '13 FATURADO',                        'SGT', 'FINALIZADO'),
+    (6, '14 DOSSIER CONCLUIDO FINI',          '',    'FINALIZADO'),
+]
+
+# Dicionários derivados da tabela para uso rápido
+STATUS_CATEGORIA_MAP = {row[1]: row[3] for row in STATUS_TABLE}
+STATUS_ETAT_MAP      = {row[1]: row[0] for row in STATUS_TABLE}
+STATUS_RESP_MAP      = {row[1]: row[2] for row in STATUS_TABLE}
+
+# Conjuntos por categoria (para compatibilidade com CSVs originais)
+EM_CURSO_STATUS      = {s for s, c in STATUS_CATEGORIA_MAP.items() if c == 'EM CURSO'}
+FINALIZADO_STATUS    = {s for s, c in STATUS_CATEGORIA_MAP.items() if c == 'FINALIZADO'}
+LICENCIAMENTO_STATUS = {s for s, c in STATUS_CATEGORIA_MAP.items() if c == 'LICENCIAMENTO'}
+
+# Enriquecer com os CSVs originais (fallback)
 def ler_status_csv(path):
     for enc in ('utf-8', 'latin-1', 'cp1252'):
         try:
@@ -109,10 +154,21 @@ def ler_status_csv(path):
             continue
     return []
 
-EM_CURSO_STATUS      = set(ler_status_csv(os.path.join(BASE, 'emcurso.csv')))
-FINALIZADO_STATUS    = set(ler_status_csv(os.path.join(BASE, 'finalizado.csv')))
-LICENCIAMENTO_STATUS = set(ler_status_csv(os.path.join(BASE, 'licenciamento.csv')))
-
+# Adicionar entradas dos CSVs originais que não estejam já na tabela
+for _s in ler_status_csv(os.path.join(BASE, 'emcurso.csv')):
+    if _s and _s not in STATUS_CATEGORIA_MAP:
+        EM_CURSO_STATUS.add(_s)
+        STATUS_CATEGORIA_MAP[_s] = 'EM CURSO'
+for _s in ler_status_csv(os.path.join(BASE, 'finalizado.csv')):
+    if _s and _s not in STATUS_CATEGORIA_MAP:
+        FINALIZADO_STATUS.add(_s)
+        STATUS_CATEGORIA_MAP[_s] = 'FINALIZADO'
+for _s in ler_status_csv(os.path.join(BASE, 'licenciamento.csv')):
+    if _s and _s not in STATUS_CATEGORIA_MAP:
+        LICENCIAMENTO_STATUS.add(_s)
+        STATUS_CATEGORIA_MAP[_s] = 'LICENCIAMENTO'
+
+# Mapeamentos legados (compatibilidade com dados antigos nos CSVs)
 STATUS_EXTRA_MAP = {
     '02.1 PROJETO POR ADJUDICAR'   : 'EM CURSO',
     '02.10 PRE VALIDA??O PROJETO'  : 'EM CURSO',
@@ -130,10 +186,21 @@ STATUS_EXTRA_MAP = {
 
 def get_categoria(status: str) -> str:
     s = str(status).strip()
-    if s in FINALIZADO_STATUS:    return 'FINALIZADO'
-    if s in LICENCIAMENTO_STATUS: return 'LICENCIAMENTO'
-    if s in EM_CURSO_STATUS:      return 'EM CURSO'
-    return STATUS_EXTRA_MAP.get(s, 'GLOBAL')
+    # 1. Tabela principal (STATUS_TABLE)
+    if s in STATUS_CATEGORIA_MAP:
+        return STATUS_CATEGORIA_MAP[s]
+    # 2. Mapeamentos legados
+    if s in STATUS_EXTRA_MAP:
+        return STATUS_EXTRA_MAP[s]
+    return 'GLOBAL'
+
+def get_etat(status: str) -> int:
+    """Retorna o ETAT (fase) de um status, ou -1 se desconhecido."""
+    return STATUS_ETAT_MAP.get(str(status).strip(), -1)
+
+def get_resp(status: str) -> str:
+    """Retorna a entidade responsável (RB/ORG/SGT) de um status."""
+    return STATUS_RESP_MAP.get(str(status).strip(), '')
 
 def calcular_faixa(pct):
     if pd.isna(pct): return 'N/A'
@@ -142,7 +209,7 @@ def calcular_faixa(pct):
     elif pct <= 100: return '75 % < X ≤ 100 %'
     else:            return '> 100 %'
 
-# ── Carregar e processar dados (lógica do dash.R) ─────────────────────────────
+# ── Carregar e processar dados ─────────────────────────────────────────────────
 def carregar_dados(caminho_csv: str) -> pd.DataFrame:
     df_raw = pd.read_csv(caminho_csv, sep=';', encoding='utf-8', on_bad_lines='skip')
     df_raw.rename(columns={df_raw.columns[9]: 'TEMPO_EXECUCAO'}, inplace=True)
@@ -170,6 +237,8 @@ def carregar_dados(caminho_csv: str) -> pd.DataFrame:
     dd['SLA_FIXO']   = dd['TIPO'].map(SLA_MAP)
     dd['TIPO_LABEL'] = dd['TIPO'].map(TIPO_LABEL).fillna(dd['TIPO'])
     dd['CATEGORIA']  = dd['RB STATUS'].apply(get_categoria)
+    dd['ETAT']       = dd['RB STATUS'].apply(get_etat)
+    dd['RESP']       = dd['RB STATUS'].apply(get_resp)
 
     dd['PCT_SLA'] = np.where(
         (dd['SLA_FIXO'] > 0) & (dd['TEMPO_EXECUCAO'] >= 0),
@@ -184,7 +253,7 @@ def carregar_dados(caminho_csv: str) -> pd.DataFrame:
 CSV_PATH = os.path.join(BASE, 'tarefasss_datas_corrigidas_final.csv')
 DF_GLOBAL = carregar_dados(CSV_PATH)
 
-# ── Construir tabela pivot para uma categoria ──────────────────────────────────
+# ── Construir tabela pivot ─────────────────────────────────────────────────────
 def build_pivot(df: pd.DataFrame, categoria: str) -> pd.DataFrame:
     if categoria == 'GLOBAL':
         sub = df.copy()
@@ -222,7 +291,7 @@ def get_stats(categoria: str) -> dict:
 
     return {'total': total, 'dentro': dentro, 'excedido': excedido, 'pct_ok': pct_ok}
 
-# ── Renderizar tabela HTML com design profissional ────────────────────────────
+# ── Renderizar tabela HTML ─────────────────────────────────────────────────────
 def render_html_table(pivot: pd.DataFrame, categoria: str) -> str:
     cor_dark, cor_mid = CAT_CORES.get(categoria, ('#212121', '#37474F'))
 
@@ -299,102 +368,80 @@ def render_html_table(pivot: pd.DataFrame, categoria: str) -> str:
     background-color: #ffffff;
   }}
   .sla-table tbody tr:hover td {{
-    background-color: #eef2ff !important;
+    background-color: #e8f0fe !important;
   }}
   .sla-table td {{
-    padding: 9px 16px;
-    border-bottom: 1px solid #e8eaf0;
+    padding: 10px 16px;
+    border-bottom: 1px solid #e8ecf0;
     vertical-align: middle;
   }}
   .sla-table td.td-tipo {{
     font-weight: 600;
-    color: #1a1a2e;
-    border-left: 4px solid {cor_mid};
-    text-align: left;
-    background-color: inherit;
+    color: {cor_dark};
+    border-right: 1px solid #e8ecf0;
   }}
   .sla-table td.td-sla {{
     text-align: center;
+    font-weight: 500;
     color: #546e7a;
-    font-style: italic;
-    font-size: 12px;
-  }}
-  .sla-table td.td-faixa {{
-    text-align: center;
+    border-right: 1px solid #e8ecf0;
   }}
   .sla-table td.td-total {{
     text-align: center;
-    font-weight: 800;
-    font-size: 14px;
+    font-weight: 700;
     color: {cor_dark};
+    font-size: 15px;
     background-color: #f0f4ff !important;
-    border-left: 2px solid #c5cae9;
   }}
   .badge {{
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
+    display: inline-block;
     min-width: 36px;
-    height: 26px;
-    padding: 0 10px;
+    padding: 3px 10px;
     border-radius: 20px;
     font-weight: 700;
     font-size: 13px;
-    line-height: 1;
-  }}
-  .badge-zero {{
-    color: #bdbdbd;
-    font-size: 16px;
-    font-weight: 400;
-  }}
-  .sub-label {{
-    display: block;
-    font-size: 10px;
-    font-weight: 400;
-    opacity: 0.85;
-    margin-top: 2px;
-    text-transform: none;
-    letter-spacing: 0;
-    color: #ffffff !important;
+    text-align: center;
   }}
 </style>
 <div class="sla-wrap">
 <table class="sla-table">
   <thead>
     <tr>
-      <th class="th-tipo">TIPOS</th>
-      <th class="th-sla">SLA<span class="sub-label">[dias]</span></th>
+      <th class="th-tipo">Tipos</th>
+      <th class="th-sla">SLA<br>[dias]</th>
 """
     for label, bg in zip(faixa_labels, faixa_header_bg):
-        html += (f'      <th style="background:{bg};color:#ffffff !important;'
-                 f'text-align:center;min-width:90px;padding:11px 16px;font-weight:700;'
-                 f'font-size:12px;text-transform:uppercase;letter-spacing:0.4px;">'
-                 f'{label}<span class="sub-label">[uni]</span></th>\n')
-
-    html += '      <th class="th-total">TOTAL</th>\n    </tr>\n  </thead>\n  <tbody>\n'
+        html += f'      <th style="background:{bg};color:#fff;text-align:center;width:110px;">{label}</th>\n'
+    html += '      <th class="th-total">Total</th>\n    </tr>\n  </thead>\n  <tbody>\n'
 
     for _, row in pivot.iterrows():
-        sla_val = row['SLA [dias]']
-        sla_str = str(int(sla_val)) if sla_val > 0 else '—'
-        html += f'    <tr>\n      <td class="td-tipo">{row["TIPOS"]}</td>\n'
-        html += f'      <td class="td-sla">{sla_str}</td>\n'
-
-        for col, (bg, fg) in zip(faixa_cols, faixa_cell):
+        html += '    <tr>\n'
+        html += f'      <td class="td-tipo">{row["TIPOS"]}</td>\n'
+        html += f'      <td class="td-sla">{int(row["SLA [dias]"])}</td>\n'
+        for col, (bg, cor) in zip(faixa_cols, faixa_cell):
             val = int(row[col])
-            if val == 0:
-                html += '      <td class="td-faixa"><span class="badge badge-zero">—</span></td>\n'
+            if val > 0:
+                html += f'      <td style="text-align:center;"><span class="badge" style="background:{bg};color:{cor};">{val}</span></td>\n'
             else:
-                html += (f'      <td class="td-faixa">'
-                         f'<span class="badge" style="background:{bg};color:{fg};">{val}</span>'
-                         f'</td>\n')
-
-        total = int(row['TOTAL'])
-        html += f'      <td class="td-total">{total}</td>\n    </tr>\n'
-
-    html += '  </tbody>\n</table>\n</div>'
+                html += f'      <td style="text-align:center;color:#bdbdbd;">—</td>\n'
+        html += f'      <td class="td-total">{int(row["TOTAL"])}</td>\n'
+        html += '    </tr>\n'
+
+    # Linha de totais
+    html += '    <tr style="border-top:2px solid #e0e0e0;">\n'
+    html += f'      <td class="td-tipo" style="font-size:13px;color:{cor_dark};">TOTAL GERAL</td>\n'
+    html += '      <td class="td-sla">—</td>\n'
+    for col, (bg, cor) in zip(faixa_cols, faixa_cell):
+        total_col = int(pivot[col].sum())
+        if total_col > 0:
+            html += f'      <td style="text-align:center;"><span class="badge" style="background:{bg};color:{cor};">{total_col}</span></td>\n'
+        else:
+            html += f'      <td style="text-align:center;color:#bdbdbd;">—</td>\n'
+    html += f'      <td class="td-total" style="font-size:17px;">{int(pivot["TOTAL"].sum())}</td>\n'
+    html += '    </tr>\n  </tbody>\n</table>\n</div>'
     return html
 
-# ── Renderizar KPI cards HTML ─────────────────────────────────────────────────
+# ── Renderizar KPIs ────────────────────────────────────────────────────────────
 def render_kpi_html(stats: dict, categoria: str) -> str:
     cor_dark, cor_mid = CAT_CORES.get(categoria, ('#212121', '#37474F'))
     pct = stats['pct_ok']
@@ -465,107 +512,46 @@ def render_kpi_html(stats: dict, categoria: str) -> str:
     return html
 
 # ── Exportações ────────────────────────────────────────────────────────────────
+def _get_export_path(prefixo: str, categoria: str) -> str:
+    """Devolve um caminho de ficheiro CSV acessível pelo Gradio."""
+    ts   = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+    nome = f"{prefixo}_{categoria.lower().replace(' ', '_')}_{ts}.csv"
+    # Tentar OUTPUT_DIR primeiro; fallback para BASE (sempre permitido)
+    for pasta in [OUTPUT_DIR, BASE]:
+        try:
+            path = os.path.join(pasta, nome)
+            open(path, 'w').close()   # teste de escrita
+            os.remove(path)
+            return path
+        except Exception:
+            continue
+    # Último recurso: ficheiro temporário no directório do projecto
+    import tempfile
+    tmp = tempfile.NamedTemporaryFile(
+        delete=False, suffix='.csv', dir=BASE, prefix=prefixo + '_'
+    )
+    tmp.close()
+    return tmp.name
 
 def exportar_csv_pivot(categoria: str) -> str:
-    try:
-        pivot = build_pivot(DF_GLOBAL, categoria)
-        ts    = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
-        nome  = f"sla_pivot_{categoria.lower().replace(' ', '_')}_{ts}.csv"
-        path  = os.path.join(OUTPUT_DIR, nome)
-        pivot.to_csv(path, index=False, encoding='utf-8-sig', sep=';')
-        return path
-    except Exception as e:
-        # Fallback: gravar em /tmp directamente
-        import tempfile
-        tmp = tempfile.NamedTemporaryFile(
-            delete=False, suffix='.csv',
-            prefix=f"sla_pivot_{categoria.lower().replace(' ','_')}_"
-        )
-        build_pivot(DF_GLOBAL, categoria).to_csv(tmp.name, index=False, encoding='utf-8-sig', sep=';')
-        return tmp.name
+    pivot = build_pivot(DF_GLOBAL, categoria)
+    path  = _get_export_path('sla_pivot', categoria)
+    pivot.to_csv(path, index=False, encoding='utf-8-sig', sep=';')
+    return path
 
 def exportar_csv_fact(categoria: str) -> str:
-    try:
-        sub = DF_GLOBAL.copy() if categoria == 'GLOBAL' else DF_GLOBAL[DF_GLOBAL['CATEGORIA'] == categoria].copy()
-        fact = sub[[
-            'SUB-CIP', 'PROJETO', 'TIPO', 'TIPO_LABEL', 'RB STATUS', 'CATEGORIA',
-            'DATA_ADJ_CLIENTE', 'DATA_PREVISTA', 'TEMPO_EXECUCAO',
-            'ATUAL', 'DIFDIAS', 'SLA_FIXO', 'PCT_SLA', 'FAIXA_SLA', 'DATA_CALCULO'
-        ]].copy()
-        fact['DATA_ADJ_CLIENTE'] = fact['DATA_ADJ_CLIENTE'].dt.strftime('%d/%m/%Y')
-        fact['DATA_PREVISTA']    = fact['DATA_PREVISTA'].dt.strftime('%d/%m/%Y')
-        ts   = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
-        nome = f"sla_fact_{categoria.lower().replace(' ', '_')}_{ts}.csv"
-        path = os.path.join(OUTPUT_DIR, nome)
-        fact.to_csv(path, index=False, encoding='utf-8-sig', sep=';')
-        return path
-    except Exception as e:
-        import tempfile
-        sub = DF_GLOBAL.copy() if categoria == 'GLOBAL' else DF_GLOBAL[DF_GLOBAL['CATEGORIA'] == categoria].copy()
-        fact = sub[[
-            'SUB-CIP', 'PROJETO', 'TIPO', 'TIPO_LABEL', 'RB STATUS', 'CATEGORIA',
-            'DATA_ADJ_CLIENTE', 'DATA_PREVISTA', 'TEMPO_EXECUCAO',
-            'ATUAL', 'DIFDIAS', 'SLA_FIXO', 'PCT_SLA', 'FAIXA_SLA', 'DATA_CALCULO'
-        ]].copy()
-        fact['DATA_ADJ_CLIENTE'] = fact['DATA_ADJ_CLIENTE'].dt.strftime('%d/%m/%Y')
-        fact['DATA_PREVISTA']    = fact['DATA_PREVISTA'].dt.strftime('%d/%m/%Y')
-        tmp = tempfile.NamedTemporaryFile(
-            delete=False, suffix='.csv',
-            prefix=f"sla_fact_{categoria.lower().replace(' ','_')}_"
-        )
-        fact.to_csv(tmp.name, index=False, encoding='utf-8-sig', sep=';')
-        return tmp.name
-
-def exportar_excel_powerbi() -> str:
-    import tempfile
-    ts   = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
-    # Tentar OUTPUT_DIR; se falhar, usar tempfile
-    try:
-        path = os.path.join(OUTPUT_DIR, f'modelo_sla_powerbi_{ts}.xlsx')
-        open(path, 'wb').close()  # testar escrita
-    except Exception:
-        tmp = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx', prefix='modelo_sla_powerbi_')
-        path = tmp.name
-        tmp.close()
-
-    with pd.ExcelWriter(path, engine='openpyxl') as writer:
-        fact = DF_GLOBAL[[
-            'SUB-CIP', 'PROJETO', 'TIPO', 'TIPO_LABEL', 'RB STATUS', 'CATEGORIA',
-            'DATA_ADJ_CLIENTE', 'DATA_PREVISTA', 'TEMPO_EXECUCAO',
-            'ATUAL', 'DIFDIAS', 'SLA_FIXO', 'PCT_SLA', 'FAIXA_SLA', 'DATA_CALCULO'
-        ]].copy()
-        fact['DATA_ADJ_CLIENTE'] = fact['DATA_ADJ_CLIENTE'].dt.strftime('%d/%m/%Y')
-        fact['DATA_PREVISTA']    = fact['DATA_PREVISTA'].dt.strftime('%d/%m/%Y')
-        fact.to_excel(writer, sheet_name='Fact_Tarefas', index=False)
-
-        for cat in ['EM CURSO', 'LICENCIAMENTO', 'FINALIZADO', 'GLOBAL']:
-            pivot = build_pivot(DF_GLOBAL, cat)
-            pivot['CATEGORIA'] = cat
-            pivot.to_excel(writer, sheet_name=cat.replace(' ', '_')[:31], index=False)
-
-        pd.DataFrame([
-            {'TIPO': t, 'TIPO_LABEL': TIPO_LABEL.get(t, t),
-             'SLA_DIAS': SLA_MAP.get(t, 0), 'ORDEM': i + 1}
-            for i, t in enumerate(TIPO_ORDER)
-        ]).to_excel(writer, sheet_name='Dim_Tipo', index=False)
-
-        all_status = sorted(DF_GLOBAL['RB STATUS'].dropna().unique())
-        pd.DataFrame({
-            'RB_STATUS': all_status,
-            'CATEGORIA': [get_categoria(s) for s in all_status],
-        }).to_excel(writer, sheet_name='Dim_Status', index=False)
-
-        pd.DataFrame({
-            'CATEGORIA': ['EM CURSO', 'LICENCIAMENTO', 'FINALIZADO', 'GLOBAL'],
-            'ORDEM'    : [1, 2, 3, 4],
-        }).to_excel(writer, sheet_name='Dim_Categoria', index=False)
-
-        pd.DataFrame({
-            'FAIXA_SLA': ['< 50 %', '50 % < X ≤ 75 %', '75 % < X ≤ 100 %', '> 100 %'],
-            'ORDEM'    : [1, 2, 3, 4],
-            'COR_HEX'  : ['#2ECC71', '#F1C40F', '#E67E22', '#E74C3C'],
-        }).to_excel(writer, sheet_name='Dim_Faixa_SLA', index=False)
-
+    sub  = DF_GLOBAL.copy() if categoria == 'GLOBAL' else DF_GLOBAL[DF_GLOBAL['CATEGORIA'] == categoria].copy()
+    cols = [
+        'SUB-CIP', 'PROJETO', 'TIPO', 'TIPO_LABEL', 'RB STATUS', 'CATEGORIA',
+        'ETAT', 'RESP',
+        'DATA_ADJ_CLIENTE', 'DATA_PREVISTA', 'TEMPO_EXECUCAO',
+        'ATUAL', 'DIFDIAS', 'SLA_FIXO', 'PCT_SLA', 'FAIXA_SLA', 'DATA_CALCULO'
+    ]
+    fact = sub[cols].copy()
+    fact['DATA_ADJ_CLIENTE'] = fact['DATA_ADJ_CLIENTE'].dt.strftime('%d/%m/%Y')
+    fact['DATA_PREVISTA']    = fact['DATA_PREVISTA'].dt.strftime('%d/%m/%Y')
+    path = _get_export_path('sla_fact', categoria)
+    fact.to_csv(path, index=False, encoding='utf-8-sig', sep=';')
     return path
 
 # ── Actualizar vista principal ─────────────────────────────────────────────────
@@ -576,22 +562,439 @@ def atualizar_vista(categoria: str):
     kpi_html    = render_kpi_html(stats, categoria)
     return tabela_html, kpi_html
 
-# ── CSS global ────────────────────────────────────────────────────────────────
-# NOTA: No Hugging Face Spaces o CSS externo pode ser sobreposto pelo tema.
-# O header usa inline styles directamente no HTML para garantir cor branca.
+# ═══════════════════════════════════════════════════════════════════════════════
+# ── RAG: Geração de contexto estruturado a partir dos dados ───────────────────
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def gerar_contexto_rag() -> str:
+    """
+    Gera um contexto estruturado e rico dos dados do dashboard SLA para RAG.
+    Inclui cruzamentos avançados, análise de risco, aging, gargalos e tendências.
+    """
+    hoje_ts  = pd.Timestamp.today().normalize()
+    hoje_str = hoje_ts.strftime('%d/%m/%Y')
+    df = DF_GLOBAL.copy()
+    linhas = []
+
+    # ── 1. CABEÇALHO ─────────────────────────────────────────────────────────
+    linhas.append("=" * 70)
+    linhas.append("DASHBOARD SLA — CONTEXTO COMPLETO PARA GESTOR DE PROJECTO")
+    linhas.append("=" * 70)
+    linhas.append(f"Data de referência : {hoje_str}")
+    linhas.append(f"Total de registos  : {len(df)}")
+    linhas.append(f"Tipos de tarefa    : {', '.join(sorted(df['TIPO_LABEL'].unique()))}")
+    linhas.append(f"Categorias activas : EM CURSO ({(df['CATEGORIA']=='EM CURSO').sum()}) | "
+                  f"LICENCIAMENTO ({(df['CATEGORIA']=='LICENCIAMENTO').sum()}) | "
+                  f"FINALIZADO ({(df['CATEGORIA']=='FINALIZADO').sum()})")
+    linhas.append("")
+
+    # ── 2. KPIs EXECUTIVOS ────────────────────────────────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("KPIs EXECUTIVOS (visão de topo)")
+    linhas.append("-" * 70)
+    for cat in ['GLOBAL', 'EM CURSO', 'LICENCIAMENTO', 'FINALIZADO']:
+        stats = get_stats(cat)
+        sub   = df if cat == 'GLOBAL' else df[df['CATEGORIA'] == cat]
+        n_sla = sub[sub['SLA_FIXO'] > 0]
+        pct_medio = round(n_sla['PCT_SLA'].mean(), 1) if len(n_sla) > 0 else 0
+        linhas.append(f"  [{cat}]")
+        linhas.append(f"    Total tarefas      : {stats['total']}")
+        linhas.append(f"    Dentro SLA (≤100%) : {stats['dentro']} ({stats['pct_ok']}%)")
+        linhas.append(f"    SLA excedido (>100%): {stats['excedido']} ({round(100-stats['pct_ok'],1)}%)")
+        linhas.append(f"    % SLA médio        : {pct_medio}%")
+        linhas.append("")
+
+    # ── 3. DISTRIBUIÇÃO DETALHADA POR TIPO E FAIXA ───────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("DISTRIBUIÇÃO POR TIPO E FAIXA SLA (por categoria)")
+    linhas.append("-" * 70)
+    for cat in ['GLOBAL', 'EM CURSO', 'LICENCIAMENTO', 'FINALIZADO']:
+        pivot = build_pivot(df, cat)
+        linhas.append(f"  [{cat}]")
+        for _, row in pivot.iterrows():
+            if row['TOTAL'] > 0:
+                t = int(row['TOTAL'])
+                exc = int(row['> 100 % [uni]'])
+                pct_exc = round(exc / t * 100, 1) if t > 0 else 0
+                linhas.append(
+                    f"    {row['TIPOS']:<20} SLA={int(row['SLA [dias]'])}d | "
+                    f"Total={t:3d} | <50%={int(row['< 50 % [uni]']):3d} | "
+                    f"50-75%={int(row['50 % < X ≤ 75 % [uni]']):3d} | "
+                    f"75-100%={int(row['75 % < X ≤ 100 % [uni]']):3d} | "
+                    f">100%={exc:3d} ({pct_exc}% do tipo)"
+                )
+        linhas.append("")
+
+    # ── 4. ANÁLISE DE RISCO: TIPOS MAIS CRÍTICOS ─────────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("ANÁLISE DE RISCO — TIPOS ORDENADOS POR TAXA DE INCUMPRIMENTO")
+    linhas.append("-" * 70)
+    risco = df[df['SLA_FIXO'] > 0].groupby('TIPO_LABEL').agg(
+        total=('TIPO_LABEL', 'count'),
+        excedido=('FAIXA_SLA', lambda x: (x == '> 100 %').sum()),
+        pct_medio=('PCT_SLA', 'mean')
+    ).reset_index()
+    risco['taxa_exc'] = (risco['excedido'] / risco['total'] * 100).round(1)
+    risco['pct_medio'] = risco['pct_medio'].round(1)
+    risco = risco.sort_values('taxa_exc', ascending=False)
+    for _, r in risco.iterrows():
+        nivel = "CRITICO" if r['taxa_exc'] >= 70 else ("ALTO" if r['taxa_exc'] >= 40 else ("MEDIO" if r['taxa_exc'] >= 20 else "BAIXO"))
+        linhas.append(
+            f"  [{nivel}] {r['TIPO_LABEL']:<20} | "
+            f"Excedido: {r['excedido']}/{r['total']} ({r['taxa_exc']}%) | "
+            f"% SLA médio: {r['pct_medio']}%"
+        )
+    linhas.append("")
+
+    # ── 5. AGING: PROJECTOS COM MAIOR DESVIO ─────────────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("AGING — TOP 20 PROJECTOS COM MAIOR EXCESSO DE SLA")
+    linhas.append("-" * 70)
+    excedidos = df[df['FAIXA_SLA'] == '> 100 %'].copy()
+    excedidos = excedidos.sort_values('PCT_SLA', ascending=False).head(20)
+    for _, row in excedidos.iterrows():
+        data_adj = row['DATA_ADJ_CLIENTE'].strftime('%d/%m/%Y') if pd.notna(row['DATA_ADJ_CLIENTE']) else 'N/D'
+        dias_atraso = int(row['ATUAL']) if pd.notna(row['ATUAL']) else 0
+        linhas.append(
+            f"  {row['PROJETO']:<14} [{row['CATEGORIA']:<13}] "
+            f"Tipo: {row['TIPO_LABEL']:<16} Status: {row['RB STATUS']:<30} "
+            f"% SLA: {row['PCT_SLA']:>6}% | Atraso: {dias_atraso:>4}d | Adj: {data_adj}"
+        )
+    linhas.append("")
+
+    # ── 6. CRUZAMENTO TIPO × STATUS (gargalos operacionais) ──────────────────
+    linhas.append("-" * 70)
+    linhas.append("CRUZAMENTO TIPO × STATUS — ONDE ESTÃO OS GARGALOS")
+    linhas.append("-" * 70)
+    cross = df[df['FAIXA_SLA'] == '> 100 %'].groupby(
+        ['TIPO_LABEL', 'RB STATUS']
+    ).size().reset_index(name='n_excedidos')
+    cross = cross.sort_values('n_excedidos', ascending=False).head(20)
+    for _, r in cross.iterrows():
+        linhas.append(
+            f"  {r['TIPO_LABEL']:<20} + {r['RB STATUS']:<35} → {r['n_excedidos']} excedidos"
+        )
+    linhas.append("")
+
+    # ── 7. CRUZAMENTO CATEGORIA × TIPO × STATUS (visão completa) ─────────────
+    linhas.append("-" * 70)
+    linhas.append("DISTRIBUIÇÃO COMPLETA: CATEGORIA × TIPO (tarefas activas)")
+    linhas.append("-" * 70)
+    cross2 = df.groupby(['CATEGORIA', 'TIPO_LABEL']).agg(
+        total=('PROJETO', 'count'),
+        excedido=('FAIXA_SLA', lambda x: (x == '> 100 %').sum())
+    ).reset_index()
+    cross2['taxa'] = (cross2['excedido'] / cross2['total'] * 100).round(1)
+    cross2 = cross2.sort_values(['CATEGORIA', 'excedido'], ascending=[True, False])
+    cat_actual = ''
+    for _, r in cross2.iterrows():
+        if r['CATEGORIA'] != cat_actual:
+            cat_actual = r['CATEGORIA']
+            linhas.append(f"  [{cat_actual}]")
+        linhas.append(
+            f"    {r['TIPO_LABEL']:<20} Total: {r['total']:3d} | "
+            f"Excedido: {r['excedido']:3d} ({r['taxa']}%)"
+        )
+    linhas.append("")
+
+    # ── 8. ANÁLISE TEMPORAL: ADJUDICAÇÕES POR MÊS ────────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("ADJUDICAÇÕES POR MÊS (volume de entrada de trabalho)")
+    linhas.append("-" * 70)
+    df_datas = df[df['DATA_ADJ_CLIENTE'].notna()].copy()
+    df_datas['MES_ADJ'] = df_datas['DATA_ADJ_CLIENTE'].dt.to_period('M')
+    mes_counts = df_datas.groupby('MES_ADJ').agg(
+        total=('PROJETO', 'count'),
+        excedido=('FAIXA_SLA', lambda x: (x == '> 100 %').sum())
+    ).reset_index().sort_values('MES_ADJ', ascending=False).head(12)
+    for _, r in mes_counts.iterrows():
+        taxa = round(r['excedido'] / r['total'] * 100, 1) if r['total'] > 0 else 0
+        linhas.append(
+            f"  {str(r['MES_ADJ']):<10} | Adjudicados: {r['total']:3d} | "
+            f"Excedidos: {r['excedido']:3d} ({taxa}%)"
+        )
+    linhas.append("")
+
+    # ── 9. PROJECTOS EM CURSO COM MAIOR RISCO IMEDIATO ────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("PROJECTOS EM CURSO COM MAIOR RISCO IMEDIATO (>75% SLA)")
+    linhas.append("-" * 70)
+    em_risco = df[
+        (df['CATEGORIA'] == 'EM CURSO') &
+        (df['PCT_SLA'] >= 75) &
+        (df['SLA_FIXO'] > 0)
+    ].sort_values('PCT_SLA', ascending=False).head(20)
+    for _, row in em_risco.iterrows():
+        data_adj = row['DATA_ADJ_CLIENTE'].strftime('%d/%m/%Y') if pd.notna(row['DATA_ADJ_CLIENTE']) else 'N/D'
+        dias_r = int(row['DIFDIAS']) if pd.notna(row['DIFDIAS']) else 0
+        linhas.append(
+            f"  {row['PROJETO']:<14} Tipo: {row['TIPO_LABEL']:<16} "
+            f"Status: {row['RB STATUS']:<30} "
+            f"% SLA: {row['PCT_SLA']:>6}% | Dias restantes: {dias_r:>4}d | Adj: {data_adj}"
+        )
+    linhas.append("")
+
+    # ── 10. DISTRIBUIÇÃO POR STATUS (todos com ETAT/RESP) ───────────────────
+    linhas.append("-" * 70)
+    linhas.append("DISTRIBUIÇÃO POR STATUS (RB STATUS) — com ETAT e RESP")
+    linhas.append("-" * 70)
+    status_counts = df['RB STATUS'].value_counts()
+    for status, count in status_counts.items():
+        cat  = get_categoria(str(status))
+        etat = get_etat(str(status))
+        resp = get_resp(str(status))
+        sub_s = df[df['RB STATUS'] == status]
+        exc_s = (sub_s['FAIXA_SLA'] == '> 100 %').sum()
+        taxa_s = round(exc_s / count * 100, 1) if count > 0 else 0
+        linhas.append(
+            f"  {status:<35} | Cat: {cat:<13} | ETAT: {etat:2d} | RESP: {resp:<3} | "
+            f"{count:3d} tarefas | Excedido: {exc_s} ({taxa_s}%)"
+        )
+    linhas.append("")
+
+    # ── 11. SLA FIXO POR TIPO ─────────────────────────────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("SLA CONTRATUAL POR TIPO DE TAREFA (dias)")
+    linhas.append("-" * 70)
+    for tipo, sla in SLA_MAP.items():
+        label = TIPO_LABEL.get(tipo, tipo)
+        linhas.append(f"  {label:<20} : {sla} dias")
+    linhas.append("")
+
+    # ── 12. TABELA DE ESTADOS DO CICLO DE VIDA ────────────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("TABELA DE ESTADOS DO CICLO DE VIDA (ETAT / Status / RESP)")
+    linhas.append("-" * 70)
+    linhas.append("  ETAT | Status                                | RESP | Categoria")
+    linhas.append("  " + "-" * 72)
+    for etat, status, resp, cat in STATUS_TABLE:
+        linhas.append(f"  {etat:4d} | {status:<40} | {resp:<4} | {cat}")
+    linhas.append("")
+    linhas.append("  Legenda ETAT : 0=Cancelado | 1=Survey/Projecto | 2=Validação Orange")
+    linhas.append("  3=Projecto Validado | 4=Trabalhos/Cadastro | 5=Cadastro | 6=Faturado/Concluído")
+    linhas.append("  Legenda RESP : RB=RB Portugal | ORG=Orange | SGT=Sogetrel")
+    linhas.append("")
+
+    # ── 13. DISTRIBUIÇÃO POR FASE (ETAT) E RESPONSÁVEL ─────────────────────
+    linhas.append("-" * 70)
+    linhas.append("DISTRIBUIÇÃO POR FASE (ETAT) E RESPONSÁVEL (RESP)")
+    linhas.append("-" * 70)
+    etat_labels = {
+        0: 'Cancelado',
+        1: 'Survey / Projecto',
+        2: 'Validação Orange',
+        3: 'Projecto Validado',
+        4: 'Trabalhos / Início Cadastro',
+        5: 'Cadastro em Curso',
+        6: 'Faturado / Concluído',
+        -1: 'Fase não mapeada (status legado)',
+    }
+    etat_counts = df['ETAT'].value_counts().sort_index()
+    for etat, count in etat_counts.items():
+        label_etat = etat_labels.get(int(etat), f'ETAT {etat}')
+        sub_e = df[df['ETAT'] == etat]
+        exc_e = (sub_e['FAIXA_SLA'] == '> 100 %').sum()
+        taxa_e = round(exc_e / count * 100, 1) if count > 0 else 0
+        linhas.append(
+            f"  ETAT {etat:2d} — {label_etat:<35} : "
+            f"{count:3d} tarefas | Excedido: {exc_e} ({taxa_e}%)"
+        )
+    linhas.append("")
+    resp_counts = df['RESP'].value_counts()
+    resp_labels = {'RB': 'RB Portugal', 'ORG': 'Orange', 'SGT': 'Sogetrel', '': 'Não mapeado'}
+    for resp, count in resp_counts.items():
+        sub_r = df[df['RESP'] == resp]
+        exc_r = (sub_r['FAIXA_SLA'] == '> 100 %').sum()
+        taxa_r = round(exc_r / count * 100, 1) if count > 0 else 0
+        linhas.append(
+            f"  RESP {resp:<3} ({resp_labels.get(resp, resp):<12}) : "
+            f"{count:3d} tarefas | Excedido: {exc_r} ({taxa_r}%)"
+        )
+    linhas.append("")
+
+    # ── 14. RESUMO EXECUTIVO AUTOMÁTICO ──────────────────────────────────────
+    linhas.append("-" * 70)
+    linhas.append("RESUMO EXECUTIVO AUTOMÁTICO")
+    linhas.append("-" * 70)
+    total_g   = len(df)
+    exc_g     = (df['FAIXA_SLA'] == '> 100 %').sum()
+    taxa_g    = round(exc_g / total_g * 100, 1) if total_g > 0 else 0
+    tipo_pior = risco.iloc[0]['TIPO_LABEL'] if len(risco) > 0 else 'N/D'
+    taxa_pior = risco.iloc[0]['taxa_exc']   if len(risco) > 0 else 0
+    tipo_melhor = risco.iloc[-1]['TIPO_LABEL'] if len(risco) > 0 else 'N/D'
+    taxa_melhor = risco.iloc[-1]['taxa_exc']   if len(risco) > 0 else 0
+    n_em_curso  = (df['CATEGORIA'] == 'EM CURSO').sum()
+    n_lic       = (df['CATEGORIA'] == 'LICENCIAMENTO').sum()
+    n_fin       = (df['CATEGORIA'] == 'FINALIZADO').sum()
+    n_criticos  = len(em_risco)
+    linhas.append(f"  Portfolio total    : {total_g} tarefas")
+    linhas.append(f"  Em Curso           : {n_em_curso} | Licenciamento: {n_lic} | Finalizado: {n_fin}")
+    linhas.append(f"  Taxa incumprimento : {taxa_g}% ({exc_g} tarefas com SLA > 100%)")
+    linhas.append(f"  Tipo mais crítico  : {tipo_pior} ({taxa_pior}% de incumprimento)")
+    linhas.append(f"  Tipo mais saudável : {tipo_melhor} ({taxa_melhor}% de incumprimento)")
+    linhas.append(f"  Projectos em risco : {n_criticos} em curso com SLA ≥ 75%")
+    linhas.append("")
+
+    return "\n".join(linhas)
+
+# Pré-calcular o contexto RAG uma vez na inicialização
+CONTEXTO_RAG = gerar_contexto_rag()
+
+def criar_cliente_nvidia(api_key: str) -> OpenAI:
+    """Cria um cliente OpenAI compatível com a API NVIDIA NIM."""
+    return OpenAI(
+        base_url="https://integrate.api.nvidia.com/v1",
+        api_key=api_key
+    )
+
+def responder_pergunta(
+    pergunta: str,
+    historico: list,
+    api_key: str,
+    modelo: str
+) -> tuple:
+    """
+    Função RAG principal: recebe a pergunta, recupera o contexto dos dados
+    e gera uma resposta usando o modelo NVIDIA NIM selecionado.
+    """
+    if not api_key or not api_key.strip():
+        historico = historico + [
+            {"role": "user", "content": pergunta},
+            {"role": "assistant", "content": "⚠️ Por favor, insira a sua chave API da NVIDIA NIM no campo acima para usar o assistente."}
+        ]
+        return historico, ""
+
+    if not pergunta or not pergunta.strip():
+        return historico, ""
+
+    try:
+        client = criar_cliente_nvidia(api_key.strip())
+
+        # Construir o prompt de sistema com o contexto dos dados
+        system_prompt = f"""Você é um Gestor de Projecto Sénior com mais de 15 anos de experiência em gestão de portfolios de telecomunicações, especializado em controlo SLA, análise de risco operacional e reporte executivo para operadores como a Orange.
+
+O seu papel é analisar os dados reais do dashboard SLA que lhe são fornecidos e responder com a profundidade e rigor de um gestor experiente. Não se limite a citar números — interprete-os, identifique padrões, riscos e oportunidades de melhoria, e sugira acções concretas quando relevante.
+
+Responda SEMPRE em português europeu (Portugal), com linguagem profissional e directa. Use os números exactos dos dados fornecidos.
+
+--- DADOS DO DASHBOARD SLA ---
+{CONTEXTO_RAG}
+--- FIM DOS DADOS ---
+
+=== CAPACIDADES DE ANÁLISE ===
+Como gestor experiente, pode e deve:
+
+1. ANÁLISE DE RISCO
+   - Identificar tipos de tarefa em estado crítico (taxa de incumprimento > 70%)
+   - Cruzar tipo × status × categoria para localizar gargalos operacionais
+   - Avaliar o impacto do aging nos projectos com maior desvio SLA
+   - Distinguir entre risco sistémico (todo o tipo falha) e risco pontual (projectos isolados)
+
+2. ANÁLISE DE DESEMPENHO
+   - Comparar taxas de cumprimento entre categorias (EM CURSO vs FINALIZADO vs LICENCIAMENTO)
+   - Avaliar o % SLA médio por tipo e identificar tendências de deterioração
+   - Analisar a distribuição por faixas (<50%, 50-75%, 75-100%, >100%) como indicador de maturidade
+   - Identificar os tipos com melhor e pior desempenho e as razões prováveis
+
+3. ANÁLISE OPERACIONAL
+   - Cruzar responsável (RESP: RB/ORG/SGT) com taxa de incumprimento para identificar onde estão os bloqueios
+   - Analisar o ciclo de vida (ETAT 0-6) e identificar em que fase os projectos ficam parados
+   - Avaliar o volume de adjudicações por mês e correlacionar com picos de incumprimento
+   - Identificar status com maior concentração de tarefas excedidas
+
+4. REPORTE EXECUTIVO
+   - Produzir resumos executivos concisos para apresentação à direcção
+   - Formatar tabelas comparativas claras com indicadores RAG (Verde/Amarelo/Vermelho)
+   - Sugerir KPIs adicionais que deveriam ser monitorizados
+   - Propor acções correctivas prioritárias com base nos dados
+
+5. ANÁLISE PREDITIVA
+   - Com base nos projectos em curso com SLA ≥ 75%, estimar quantos vão exceder o prazo
+   - Identificar padrões de adjudicação que historicamente levam a incumprimento
+   - Avaliar se a taxa de incumprimento está a melhorar ou piorar com base nos dados históricos disponíveis
+
+=== REGRAS DE RESPOSTA ===
+- Use SEMPRE os números exactos dos dados fornecidos
+- Quando apresentar análises, estruture em: Situação → Análise → Recomendação
+- Use tabelas markdown para comparações com 3 ou mais itens
+- Classifique o nível de risco: 🔴 CRÍTICO (≥70% incumprimento) | 🟠 ALTO (40-69%) | 🟡 MÉDIO (20-39%) | 🟢 BAIXO (<20%)
+- Se a pergunta não puder ser respondida com os dados disponíveis, diga claramente e sugira o que seria necessário para responder
+- Para perguntas sobre projectos específicos, forneça o contexto completo (tipo, status, ETAT, % SLA, data adjudicação)
+- Quando identificar problemas, proponha sempre pelo menos uma acção correctiva concreta
+- Mantenha o contexto da conversa anterior para análises sequenciais
+
+=== LEGENDA SLA ===
+🟢 < 50%   : Dentro do prazo — execução saudável
+🟡 50-75%  : Atenção — monitorização reforçada necessária  
+🟠 75-100% : Crítico — intervenção urgente recomendada
+🔴 > 100%  : SLA excedido — incumprimento contratual, escalada necessária
+"""
+
+        # Construir o histórico de mensagens para o modelo
+        messages = [{"role": "system", "content": system_prompt}]
+
+        # Adicionar histórico anterior (máximo 10 turnos para não exceder contexto)
+        for msg in historico[-10:]:
+            messages.append({"role": msg["role"], "content": msg["content"]})
+
+        # Adicionar a pergunta atual
+        messages.append({"role": "user", "content": pergunta})
+
+        # Chamar a API NVIDIA NIM
+        response = client.chat.completions.create(
+            model=modelo,
+            messages=messages,
+            temperature=0.2,
+            max_tokens=1500,
+        )
+
+        resposta = response.choices[0].message.content
+
+        # Atualizar o histórico
+        historico = historico + [
+            {"role": "user", "content": pergunta},
+            {"role": "assistant", "content": resposta}
+        ]
+
+        return historico, ""
+
+    except Exception as e:
+        erro = str(e)
+        if "401" in erro or "Unauthorized" in erro or "invalid_api_key" in erro.lower():
+            msg_erro = "❌ Chave API inválida ou sem autorização. Verifique a sua chave NVIDIA NIM em [build.nvidia.com](https://build.nvidia.com)."
+        elif "429" in erro or "rate_limit" in erro.lower():
+            msg_erro = "⏳ Limite de pedidos atingido. Aguarde alguns segundos e tente novamente."
+        elif "model" in erro.lower() and "not found" in erro.lower():
+            msg_erro = f"❌ Modelo '{modelo}' não encontrado. Tente selecionar outro modelo."
+        else:
+            msg_erro = f"❌ Erro ao contactar a API NVIDIA NIM: {erro}"
+
+        historico = historico + [
+            {"role": "user", "content": pergunta},
+            {"role": "assistant", "content": msg_erro}
+        ]
+        return historico, ""
+
+def limpar_chat():
+    """Limpa o histórico do chat."""
+    return [], ""
+
+def perguntas_rapidas(pergunta_selecionada: str) -> str:
+    """Retorna a pergunta rápida selecionada para o campo de input."""
+    return pergunta_selecionada
+
+# ── CSS global ─────────────────────────────────────────────────────────────────
 CSS = """
 @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap');
-
 body, .gradio-container {
     font-family: 'Inter', 'Segoe UI', Arial, sans-serif !important;
     background: #F0F2F8 !important;
 }
 .gradio-container {
-    max-width: 1280px !important;
+    max-width: 1400px !important;
     margin: 0 auto !important;
     padding: 0 !important;
 }
-/* Header — reforço via CSS (o inline style no HTML é a fonte primária) */
 .sla-header-wrap,
 .sla-header-wrap *,
 .sla-header-wrap h1,
@@ -651,6 +1054,18 @@ body, .gradio-container {
     margin-top: 16px;
     flex-wrap: wrap;
 }
+.chat-container {
+    background: white;
+    border-radius: 12px;
+    padding: 20px;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.06);
+}
+.rag-header {
+    background: linear-gradient(135deg, #0D47A1 0%, #1565C0 50%, #1976D2 100%);
+    border-radius: 10px;
+    padding: 16px 20px;
+    margin-bottom: 16px;
+}
 footer { display: none !important; }
 .gr-panel, .gr-box { border-radius: 12px !important; }
 """
@@ -660,13 +1075,8 @@ CATEGORIAS = ['EM CURSO', 'LICENCIAMENTO', 'FINALIZADO', 'GLOBAL']
 DATA_REF   = pd.Timestamp.today().strftime('%d/%m/%Y')
 N_TOTAL    = len(DF_GLOBAL)
 
-# ── Header HTML — cor branca garantida via 3 mecanismos simultâneos:
-#    1. style="" inline em cada elemento
-#    2. -webkit-text-fill-color (sobrepõe alguns temas WebKit/Blink)
-#    3. <font color> como fallback para parsers que removem style
 HEADER_HTML = f"""
 <style>
-  /* Especificidade máxima para o header — funciona no Hugging Face Spaces */
   div.sla-header-wrap {{
     background: linear-gradient(135deg, #0D47A1 0%, #1565C0 50%, #1976D2 100%) !important;
     padding: 28px 36px 22px !important;
@@ -708,78 +1118,221 @@ HEADER_HTML = f"""
     <font color="#ffffff">
       Controlo SLA por tipo de tarefa &nbsp;·&nbsp; Distribuição por faixas de percentagem
       &nbsp;·&nbsp; {N_TOTAL} registos &nbsp;·&nbsp; Referência: {DATA_REF}
+      &nbsp;·&nbsp; 🤖 RAG com NVIDIA NIM
     </font>
   </p>
 </div>
 """
 
-with gr.Blocks(title="Dashboard SLA") as demo:
+MODELOS_NVIDIA = [
+    "meta/llama-3.3-70b-instruct",
+    "meta/llama-3.1-70b-instruct",
+    "meta/llama-3.1-8b-instruct",
+    "mistralai/mistral-7b-instruct-v0.3",
+    "mistralai/mixtral-8x7b-instruct-v0.1",
+    "microsoft/phi-3-mini-128k-instruct",
+    "google/gemma-2-9b-it",
+]
 
-    gr.HTML(HEADER_HTML)
+PERGUNTAS_SUGERIDAS = [
+    # ─ Resumos executivos
+    "📊 Faz um resumo executivo completo do estado actual do portfolio SLA",
+    "🚨 Quais são os 3 tipos de tarefa mais críticos neste momento e que acções recomendas?",
+    "📈 Compara o desempenho SLA entre as categorias Em Curso, Licenciamento e Finalizado",
+    # ─ Análise de risco
+    "⚠️ Quais os projectos em curso com maior risco de incumprimento SLA nas próximas semanas?",
+    "🔴 Identifica todos os gargalos operacionais cruzando tipo de tarefa com status actual",
+    "🔍 Qual é o padrão de incumprimento no tipo PAR? Porque acha que acontece?",
+    # ─ Análise por tipo
+    "📉 Qual o tipo de tarefa com maior taxa de incumprimento e qual o % SLA médio?",
+    "📈 Qual o tipo de tarefa com melhor desempenho SLA? O que pode explicar esse resultado?",
+    "📊 Faz uma tabela comparativa de todos os tipos com: total, excedidos, taxa e % SLA médio",
+    # ─ Análise por responsavel
+    "👥 Qual é a distribuição de tarefas e incumprimento por responsável (RB, Orange, Sogetrel)?",
+    "🔍 Em que fase do ciclo de vida (ETAT) estão concentrados os maiores atrasos?",
+    # ─ Aging e projectos específicos
+    "⏰ Lista os 10 projectos com maior desvio SLA e o número de dias de atraso",
+    "📅 Analisa as adjudicações por mês: há meses com maior volume e pior desempenho?",
+    # ─ Licenciamento
+    "🏗️ Qual é o estado do Licenciamento? Quais os tipos mais problemáticos nessa categoria?",
+    # ─ Preditivo e recomendações
+    "🔮 Com base nos projectos em curso com SLA ≥75%, quantos estimas que vão exceder o prazo?",
+    "💡 Que 3 acções correctivas prioritárias recomendas para melhorar a taxa de cumprimento global?",
+]
 
-    # ── Selector de categoria ────────────────────────────────────────────────
-    with gr.Row():
-        cat_selector = gr.Radio(
-            choices=CATEGORIAS,
-            value='EM CURSO',
-            label='Categoria',
-            interactive=True,
-            elem_classes=['cat-selector'],
-        )
+with gr.Blocks(title="Dashboard SLA + RAG NVIDIA NIM") as demo:
 
-    # ── Tabela + KPIs ────────────────────────────────────────────────────────
-    with gr.Row(equal_height=True):
-        with gr.Column(scale=4):
-            tabela_out = gr.HTML()
-        with gr.Column(scale=1, min_width=220):
-            kpi_out = gr.HTML()
-
-    # ── Secção de exportação ─────────────────────────────────────────────────
-    gr.HTML('<div class="export-section"><b style="font-size:13px;color:#37474F;'
-            'text-transform:uppercase;letter-spacing:0.6px;">⬇ Exportar Dados</b></div>')
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("**Pivot da categoria** — distribuição por faixas SLA")
-            btn_pivot  = gr.Button("⬇ CSV — Tabela Pivot", variant="secondary", elem_classes=["btn-export"])
-            file_pivot = gr.File(label="", show_label=False)
-
-        with gr.Column(scale=1):
-            gr.Markdown("**Dados calculados completos** — todos os campos do dash.R")
-            btn_fact  = gr.Button("⬇ CSV — Dados Calculados", variant="secondary", elem_classes=["btn-export"])
-            file_fact = gr.File(label="", show_label=False)
-
-
-
-    # ── Legenda ──────────────────────────────────────────────────────────────
-    gr.HTML("""
-    <div class="legenda-bar">
-      <span style="font-size:12px;font-weight:700;color:#546e7a;text-transform:uppercase;letter-spacing:0.5px;">Legenda:</span>
-      <span style="display:inline-flex;align-items:center;gap:6px;font-size:13px;">
-        <span style="width:14px;height:14px;border-radius:50%;background:#2E7D32;display:inline-block;"></span>
-        <b style="color:#1B5E20">&lt; 50 %</b> — Dentro do prazo
-      </span>
-      <span style="display:inline-flex;align-items:center;gap:6px;font-size:13px;">
-        <span style="width:14px;height:14px;border-radius:50%;background:#E65100;display:inline-block;"></span>
-        <b style="color:#E65100">50 % &lt; X ≤ 75 %</b> — Atenção
-      </span>
-      <span style="display:inline-flex;align-items:center;gap:6px;font-size:13px;">
-        <span style="width:14px;height:14px;border-radius:50%;background:#BF360C;display:inline-block;"></span>
-        <b style="color:#BF360C">75 % &lt; X ≤ 100 %</b> — Crítico
-      </span>
-      <span style="display:inline-flex;align-items:center;gap:6px;font-size:13px;">
-        <span style="width:14px;height:14px;border-radius:50%;background:#B71C1C;display:inline-block;"></span>
-        <b style="color:#B71C1C">&gt; 100 %</b> — SLA excedido
-      </span>
-    </div>
-    """)
-
-    # ── Eventos ──────────────────────────────────────────────────────────────
+    gr.HTML(HEADER_HTML)
+
+    # ── Tabs principais ──────────────────────────────────────────────────────
+    with gr.Tabs():
+
+        # ── Tab 1: Dashboard ─────────────────────────────────────────────────
+        with gr.Tab("📊 Dashboard SLA"):
+
+            with gr.Row():
+                cat_selector = gr.Radio(
+                    choices=CATEGORIAS,
+                    value='EM CURSO',
+                    label='Categoria',
+                    interactive=True,
+                    elem_classes=['cat-selector'],
+                )
+
+            with gr.Row(equal_height=True):
+                with gr.Column(scale=4):
+                    tabela_out = gr.HTML()
+                with gr.Column(scale=1, min_width=220):
+                    kpi_out = gr.HTML()
+
+            gr.HTML('<div class="export-section"><b style="font-size:13px;color:#37474F;'
+                    'text-transform:uppercase;letter-spacing:0.6px;">⬇ Exportar Dados</b></div>')
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("**Pivot da categoria** — distribuição por faixas SLA")
+                    btn_pivot  = gr.Button("⬇ CSV — Tabela Pivot", variant="secondary", elem_classes=["btn-export"])
+                    file_pivot = gr.File(label="", show_label=False)
+
+                with gr.Column(scale=1):
+                    gr.Markdown("**Dados calculados completos** — todos os campos do dash.R")
+                    btn_fact  = gr.Button("⬇ CSV — Dados Calculados", variant="secondary", elem_classes=["btn-export"])
+                    file_fact = gr.File(label="", show_label=False)
+
+            gr.HTML("""
+            <div class="legenda-bar">
+              <span style="font-size:12px;font-weight:700;color:#546e7a;text-transform:uppercase;letter-spacing:0.5px;">Legenda:</span>
+              <span style="display:inline-flex;align-items:center;gap:6px;font-size:13px;">
+                <span style="width:14px;height:14px;border-radius:50%;background:#2E7D32;display:inline-block;"></span>
+                <b style="color:#1B5E20">&lt; 50 %</b> — Dentro do prazo
+              </span>
+              <span style="display:inline-flex;align-items:center;gap:6px;font-size:13px;">
+                <span style="width:14px;height:14px;border-radius:50%;background:#E65100;display:inline-block;"></span>
+                <b style="color:#E65100">50 % &lt; X ≤ 75 %</b> — Atenção
+              </span>
+              <span style="display:inline-flex;align-items:center;gap:6px;font-size:13px;">
+                <span style="width:14px;height:14px;border-radius:50%;background:#BF360C;display:inline-block;"></span>
+                <b style="color:#BF360C">75 % &lt; X ≤ 100 %</b> — Crítico
+              </span>
+              <span style="display:inline-flex;align-items:center;gap:6px;font-size:13px;">
+                <span style="width:14px;height:14px;border-radius:50%;background:#B71C1C;display:inline-block;"></span>
+                <b style="color:#B71C1C">&gt; 100 %</b> — SLA excedido
+              </span>
+            </div>
+            """)
+
+        # ── Tab 2: Assistente RAG ────────────────────────────────────────────
+        with gr.Tab("🤖 Assistente IA (RAG)"):
+
+            gr.HTML("""
+            <div style="background:linear-gradient(135deg,#0D47A1 0%,#1565C0 50%,#1976D2 100%);
+                        border-radius:10px;padding:16px 20px;margin-bottom:16px;">
+              <h3 style="margin:0 0 6px;color:#fff;font-size:16px;font-weight:700;">
+                🤖 Assistente RAG — NVIDIA NIM
+              </h3>
+              <p style="margin:0;color:rgba(255,255,255,0.85);font-size:13px;">
+                Faça perguntas em linguagem natural sobre os dados do dashboard SLA.
+                O assistente usa os dados reais carregados para responder com precisão.
+              </p>
+            </div>
+            """)
+
+            # Configuração da API
+            with gr.Row():
+                with gr.Column(scale=3):
+                    api_key_input = gr.Textbox(
+                        label="🔑 Chave API NVIDIA NIM",
+                        placeholder="nvapi-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+                        type="password",
+                        info="Obtenha a sua chave gratuita em build.nvidia.com → Get API Key"
+                    )
+                with gr.Column(scale=2):
+                    modelo_selector = gr.Dropdown(
+                        choices=MODELOS_NVIDIA,
+                        value="meta/llama-3.3-70b-instruct",
+                        label="🧠 Modelo NVIDIA NIM",
+                        info="Llama 3.3 70B é o modelo recomendado"
+                    )
+
+            gr.HTML("""
+            <div style="background:#e8f4fd;border-left:4px solid #1976D2;border-radius:6px;
+                        padding:10px 14px;margin:8px 0 16px;font-size:12px;color:#1565C0;">
+              <b>Como obter a chave API gratuita:</b> Aceda a
+              <a href="https://build.nvidia.com" target="_blank" style="color:#0D47A1;font-weight:600;">build.nvidia.com</a>
+              → faça login → clique em "Get API Key" → copie e cole acima.
+              A NVIDIA oferece créditos gratuitos para desenvolvimento.
+            </div>
+            """)
+
+            # Perguntas rápidas
+            with gr.Row():
+                perguntas_dropdown = gr.Dropdown(
+                    choices=PERGUNTAS_SUGERIDAS,
+                    label="💡 Perguntas sugeridas (clique para usar)",
+                    value=None,
+                    interactive=True,
+                )
+
+            # Chat
+            chatbot = gr.Chatbot(
+                label="Conversa com o Assistente SLA",
+                height=480,
+                avatar_images=(None, "https://build.nvidia.com/favicon.ico"),
+                placeholder="<div style='text-align:center;padding:40px;color:#9e9e9e;'>"
+                            "<div style='font-size:40px;margin-bottom:12px;'>🤖</div>"
+                            "<b>Assistente SLA com NVIDIA NIM</b><br>"
+                            "<span style='font-size:13px;'>Insira a sua chave API e faça uma pergunta sobre os dados do dashboard</span>"
+                            "</div>"
+            )
+
+            with gr.Row():
+                pergunta_input = gr.Textbox(
+                    label="",
+                    placeholder="Ex: Qual é a taxa de cumprimento global? Quais os tipos com mais SLA excedido?",
+                    lines=2,
+                    scale=5,
+                    show_label=False,
+                )
+                with gr.Column(scale=1, min_width=120):
+                    btn_enviar = gr.Button("Enviar ▶", variant="primary", size="lg")
+                    btn_limpar = gr.Button("🗑 Limpar", variant="secondary")
+
+            # Informação sobre o contexto RAG
+            with gr.Accordion("ℹ️ Ver contexto RAG (dados enviados ao modelo)", open=False):
+                gr.Textbox(
+                    value=CONTEXTO_RAG,
+                    label="Contexto estruturado dos dados (enviado ao modelo em cada pergunta)",
+                    lines=20,
+                    interactive=False,
+                )
+
+    # ── Eventos — Dashboard ──────────────────────────────────────────────────
     cat_selector.change(fn=atualizar_vista, inputs=cat_selector, outputs=[tabela_out, kpi_out])
     demo.load(fn=lambda: atualizar_vista('EM CURSO'), outputs=[tabela_out, kpi_out])
     btn_pivot.click(fn=exportar_csv_pivot, inputs=cat_selector, outputs=file_pivot)
     btn_fact.click(fn=exportar_csv_fact,   inputs=cat_selector, outputs=file_fact)
 
+    # ── Eventos — RAG Chat ───────────────────────────────────────────────────
+    btn_enviar.click(
+        fn=responder_pergunta,
+        inputs=[pergunta_input, chatbot, api_key_input, modelo_selector],
+        outputs=[chatbot, pergunta_input],
+    )
+    pergunta_input.submit(
+        fn=responder_pergunta,
+        inputs=[pergunta_input, chatbot, api_key_input, modelo_selector],
+        outputs=[chatbot, pergunta_input],
+    )
+    btn_limpar.click(
+        fn=limpar_chat,
+        outputs=[chatbot, pergunta_input],
+    )
+    perguntas_dropdown.change(
+        fn=perguntas_rapidas,
+        inputs=perguntas_dropdown,
+        outputs=pergunta_input,
+    )
+
 
 if __name__ == '__main__':
     demo.launch(
@@ -788,4 +1341,5 @@ if __name__ == '__main__':
         share=False,
         css=CSS,
         theme=gr.themes.Base(),
-    )
+        allowed_paths=[OUTPUT_DIR, BASE],
+    )