Update app.py

app.py

@@ -1,152 +1,246 @@
-# graph_agent.py — GraphRAG Agent: GPT-4o-mini + Neo4j Cypher
-from openai import OpenAI
-import re
-
-SYSTEM_PROMPT = """Você é um agente especialista em Graph Neural Networks para detecção de fraude.
-Você tem acesso a uma base de conhecimento em grafo Neo4j com 5 projetos de GNN.
-
-PROJETOS DISPONÍVEIS:
-1. Sistema Imune Digital — Deep RL (DQN Dueling), 3 agentes especialistas
-2. HetGNN Fraud — Grafo heterogêneo, HGTConv, 5 tipos de nó
-3. TGN Fraud Detection — Temporal GNN, memória GRU, stream e-commerce
-4. DOMINANT — Anomaly detection sem labels (IJCAI 2019)
-5. GraphSAGE Elliptic — Dataset real Bitcoin, inductive learning
-
-SCHEMA DO GRAFO:
-Nós: Projeto, Tecnologia, Conceito, Paper, Metrica
-Arestas: 
-  (Projeto)-[:USA]->(Tecnologia)
-  (Projeto)-[:IMPLEMENTA]->(Conceito)
-  (Projeto)-[:REFERENCIA]->(Paper)
-  (Projeto)-[:TEM_METRICA]->(Metrica)
-  (Projeto)-[:DIFERENTE_DE]->(Projeto)
-
-PROPRIEDADES:
-  Projeto: nome, descricao, paradigma, dado, url, emoji, ano
-  Tecnologia: nome
-  Conceito: nome, descricao
-  Paper: titulo, autores, venue, modelo
-  Metrica: projeto, tipo, valor, dataset
-
-Sua tarefa: 
-1. Gerar uma query Cypher para buscar informação relevante no grafo
-2. A query deve ser eficiente e específica à pergunta
-3. Retornar APENAS o Cypher, sem explicação, dentro de ```cypher ... ```
-
-Exemplos:
-Pergunta: "Quais projetos usam PyTorch Geometric?"
-```cypher
-MATCH (p:Projeto)-[:USA]->(t:Tecnologia {nome: 'PyTorch Geometric'})
-RETURN p.nome, p.descricao, p.url
-```
-
-Pergunta: "Qual projeto tem maior AUC?"
-```cypher
-MATCH (p:Projeto)-[:TEM_METRICA]->(m:Metrica {tipo: 'AUC'})
-RETURN p.nome, m.valor, m.dataset
-ORDER BY m.valor DESC
-```
-
-Pergunta: "Me explique o conceito de Inductive Learning"
-```cypher
-MATCH (c:Conceito {nome: 'Inductive Learning'})<-[:IMPLEMENTA]-(p:Projeto)
-RETURN c.nome, c.descricao, collect(p.nome) AS projetos
-```"""
-
-ANSWER_PROMPT = """Você é Daniel Fonseca, ML Engineer especialista em Graph Neural Networks para detecção de fraude.
-Responda de forma técnica, clara e entusiasmada sobre seus projetos.
-
-Contexto do grafo Neo4j:
-{context}
-
-Pergunta do usuário: {question}
-
-Instruções:
-- Responda em português
-- Seja específico e técnico
-- Cite os projetos relevantes com seus emojis
-- Se tiver URL de projeto, mencione que pode ser acessado no Hugging Face
-- Máximo 4 parágrafos
-- Finalize com uma frase que convide o usuário a explorar mais"""
-
-
-class GraphRAGAgent:
-    def __init__(self, openai_api_key: str, neo4j_driver, neo4j_database: str):
-        self.client   = OpenAI(api_key=openai_api_key)
-        self.driver   = neo4j_driver
-        self.database = neo4j_database
-        self.model    = "gpt-4o-mini"
-
-    def gerar_cypher(self, pergunta: str) -> str:
-        """GPT gera Cypher a partir da pergunta em linguagem natural."""
-        resp = self.client.chat.completions.create(
-            model=self.model,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user",   "content": pergunta}
-            ],
-            temperature=0.1,
-            max_tokens=300,
-        )
-        texto = resp.choices[0].message.content
-        # Extrai o Cypher do bloco de código
-        match = re.search(r'```cypher\s*(.*?)\s*```', texto, re.DOTALL)
-        if match:
-            return match.group(1).strip()
-        # Fallback: tenta extrair qualquer bloco de código
-        match = re.search(r'```\s*(.*?)\s*```', texto, re.DOTALL)
-        if match:
-            return match.group(1).strip()
-        return texto.strip()
-
-    def executar_cypher(self, cypher: str) -> list:
-        """Executa Cypher no Neo4j e retorna resultados."""
-        try:
-            with self.driver.session(database=self.database) as session:
-                result = session.run(cypher)
-                return [dict(record) for record in result]
-        except Exception as e:
-            return [{"erro": str(e)}]
-
-    def formatar_contexto(self, resultados: list) -> str:
-        """Formata resultados do Neo4j em texto para o LLM."""
-        if not resultados:
-            return "Nenhum resultado encontrado no grafo."
-        if len(resultados) == 1 and "erro" in resultados[0]:
-            return f"Erro na query: {resultados[0]['erro']}"
-        linhas = []
-        for r in resultados[:10]:  # max 10 resultados
-            linha = " | ".join(f"{k}: {v}" for k, v in r.items() if v is not None)
-            linhas.append(linha)
-        return "\n".join(linhas)
-
-    def gerar_resposta(self, pergunta: str, contexto: str) -> str:
-        """GPT gera resposta final com base no contexto do grafo."""
-        prompt = ANSWER_PROMPT.format(context=contexto, question=pergunta)
-        resp = self.client.chat.completions.create(
-            model=self.model,
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.7,
-            max_tokens=600,
-        )
-        return resp.choices[0].message.content
-
-    def responder(self, pergunta: str) -> dict:
-        """
-        Pipeline completo:
-        1. Gera Cypher
-        2. Executa no Neo4j
-        3. Formata contexto
-        4. Gera resposta
-        """
-        cypher     = self.gerar_cypher(pergunta)
-        resultados = self.executar_cypher(cypher)
-        contexto   = self.formatar_contexto(resultados)
-        resposta   = self.gerar_resposta(pergunta, contexto)
-
-        return {
-            "cypher":     cypher,
-            "resultados": resultados,
-            "contexto":   contexto,
-            "resposta":   resposta,
-        }
+# app.py — GraphRAG Portfolio Agent | GPT-4o-mini + Neo4j
+import streamlit as st
+import os
+
+st.set_page_config(
+    page_title="GraphRAG — Portfolio Agent",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# ── SESSION STATE ─────────────────────────────────────────────
+for k, v in {
+    'messages': [], 'neo4j': None, 'neo4j_ok': False,
+    'agent': None, 'schema_ok': False,
+    'openai_key': '', 'graph_stats': None,
+}.items():
+    if k not in st.session_state:
+        st.session_state[k] = v
+
+# ── HELPERS ───────────────────────────────────────────────────
+def get_neo4j_config():
+    cfg = {}
+    try:
+        s = st.secrets
+        if 'NEO4J_URI' in s:
+            return {'uri': s['NEO4J_URI'], 'username': s['NEO4J_USERNAME'],
+                    'password': s['NEO4J_PASSWORD'],
+                    'database': s.get('NEO4J_DATABASE', 'neo4j')}
+        if 'neo4j' in s:
+            n = s['neo4j']
+            return {'uri': n.get('uri',''), 'username': n.get('username',''),
+                    'password': n.get('password',''), 'database': n.get('database','neo4j')}
+    except Exception:
+        pass
+    return {'uri': os.getenv('NEO4J_URI',''), 'username': os.getenv('NEO4J_USERNAME',''),
+            'password': os.getenv('NEO4J_PASSWORD',''), 'database': os.getenv('NEO4J_DATABASE','neo4j')}
+
+def get_openai_key():
+    try:
+        if 'OPENAI_API_KEY' in st.secrets:
+            return st.secrets['OPENAI_API_KEY']
+    except Exception:
+        pass
+    return os.getenv('OPENAI_API_KEY', st.session_state.openai_key)
+
+def conectar_neo4j():
+    if st.session_state.neo4j is not None:
+        return st.session_state.neo4j
+    try:
+        from neo4j import GraphDatabase
+        cfg = get_neo4j_config()
+        if not all([cfg['uri'], cfg['username'], cfg['password']]):
+            return None
+        driver = GraphDatabase.driver(cfg['uri'], auth=(cfg['username'], cfg['password']))
+        with driver.session(database=cfg['database']) as s:
+            s.run('RETURN 1')
+        st.session_state.neo4j    = (driver, cfg['database'])
+        st.session_state.neo4j_ok = True
+        return st.session_state.neo4j
+    except Exception as e:
+        st.session_state.neo4j_ok = False
+        return None
+
+def criar_agente(openai_key):
+    try:
+        from graph_agent import GraphRAGAgent
+        conn = st.session_state.neo4j
+        if conn is None:
+            return None
+        driver, database = conn
+        return GraphRAGAgent(openai_key, driver, database)
+    except Exception as e:
+        st.error(f"Erro ao criar agente: {e}")
+        return None
+
+# ── SIDEBAR ───────────────────────────────────────────────────
+with st.sidebar:
+    st.title("🤖 GraphRAG Agent")
+    st.caption("GPT-4o-mini · Neo4j · Cypher")
+    st.divider()
+
+    # Neo4j status
+    conn = conectar_neo4j()
+    if st.session_state.neo4j_ok:
+        st.success("🗄️ Neo4j Conectado")
+    else:
+        st.error("Neo4j offline")
+        st.info("Configure NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD nos secrets do HF Space.")
+
+    st.divider()
+
+    # OpenAI Key
+    st.markdown("#### 🔑 OpenAI API Key")
+    key_input = st.text_input(
+        "Chave", type="password",
+        value=st.session_state.openai_key,
+        placeholder="sk-...",
+        help="Ou configure OPENAI_API_KEY nos secrets do HF"
+    )
+    if key_input:
+        st.session_state.openai_key = key_input
+
+    openai_key = get_openai_key()
+    if openai_key:
+        st.success("✅ OpenAI Key configurada")
+    else:
+        st.warning("OpenAI Key não configurada")
+
+    st.divider()
+
+    # Popular grafo
+    st.markdown("#### 🧬 Base de Conhecimento")
+    if st.session_state.neo4j_ok:
+        if st.button("📥 Popular Grafo Neo4j", use_container_width=True, type="primary"):
+            try:
+                from graph_knowledge import popular_neo4j, verificar_schema
+                driver, database = st.session_state.neo4j
+                with st.spinner("Populando Neo4j com projetos GNN..."):
+                    n, erros = popular_neo4j(driver, database)
+                    nos, arestas = verificar_schema(driver, database)
+                    st.session_state.graph_stats = {'nos': nos, 'arestas': arestas}
+                    st.session_state.schema_ok   = True
+                st.success(f"✅ {n} statements executados!")
+                if erros:
+                    st.warning(f"{len(erros)} avisos (normal em re-execuções)")
+            except Exception as e:
+                st.error(f"Erro: {e}")
+
+        if st.session_state.graph_stats:
+            st.markdown("**Nós no grafo:**")
+            for item in st.session_state.graph_stats['nos']:
+                col1, col2 = st.columns([3,1])
+                col1.caption(item['tipo'])
+                col2.markdown(f"**{item['total']}**")
+            total_ar = sum(a['total'] for a in st.session_state.graph_stats['arestas'])
+            st.caption(f"Total de arestas: **{total_ar}**")
+    else:
+        st.info("Conecte o Neo4j primeiro")
+
+    st.divider()
+    if st.button("🗑️ Limpar Chat", use_container_width=True):
+        st.session_state.messages = []
+        st.rerun()
+
+# ── MAIN ──────────────────────────────────────────────────────
+st.title("🤖 Portfolio GraphRAG Agent")
+st.markdown("Pergunte qualquer coisa sobre os **5 projetos de GNN** — o agente consulta o Neo4j com Cypher gerado pelo GPT e responde.")
+st.divider()
+
+# Alertas de configuração
+if not get_openai_key():
+    st.warning("⬅️ Configure sua OpenAI API Key na sidebar para usar o agente.")
+
+if not st.session_state.neo4j_ok:
+    st.error("Neo4j não conectado. Configure as credenciais na sidebar.")
+
+if st.session_state.neo4j_ok and not st.session_state.schema_ok:
+    st.info("⬅️ Clique em **Popular Grafo Neo4j** na sidebar para carregar a base de conhecimento.")
+
+# ── COMO FUNCIONA ─────────────────────────────────────────────
+if not st.session_state.messages:
+    with st.expander("ℹ️ Como funciona o GraphRAG?", expanded=True):
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            st.markdown("**1. Você pergunta**")
+            st.markdown("Em linguagem natural, sobre qualquer projeto, tecnologia ou conceito do portfólio.")
+        with c2:
+            st.markdown("**2. GPT gera Cypher**")
+            st.markdown("O GPT-4o-mini analisa o schema do grafo e gera uma query Cypher para o Neo4j.")
+        with c3:
+            st.markdown("**3. Neo4j responde**")
+            st.markdown("A query é executada, o contexto é passado de volta ao GPT que formula a resposta final.")
+
+    st.markdown("### 💡 Sugestões de perguntas")
+    sugestoes = [
+        "Quais projetos usam PyTorch Geometric?",
+        "Qual projeto tem maior AUC?",
+        "Me explique o DOMINANT",
+        "Qual a diferença entre HetGNN e GraphSAGE?",
+        "Quais papers são referenciados?",
+        "Que conceitos o TGN implementa?",
+        "Qual projeto usa dado real?",
+        "Como funciona Inductive Learning?",
+    ]
+    cols = st.columns(4)
+    for i, sug in enumerate(sugestoes):
+        with cols[i % 4]:
+            if st.button(sug, key=f"sug_{i}", use_container_width=True):
+                st.session_state.pending_question = sug
+                st.rerun()
+
+# ── CHAT HISTORY ─────────────────────────────────────────────
+for msg in st.session_state.messages:
+    with st.chat_message(msg["role"], avatar="🧑" if msg["role"]=="user" else "🤖"):
+        if msg["role"] == "assistant" and msg.get("cypher"):
+            with st.expander(f"🔍 Cypher gerado ({msg.get('n_resultados', 0)} resultados)", expanded=False):
+                st.code(msg["cypher"], language="cypher")
+        st.markdown(msg["content"])
+
+# ── INPUT ─────────────────────────────────────────────────────
+# Processa pergunta pendente (de botão de sugestão)
+pergunta_pendente = st.session_state.pop("pending_question", None)
+
+pergunta = st.chat_input("Pergunte sobre os projetos de GNN...") or pergunta_pendente
+
+if pergunta and get_openai_key() and st.session_state.neo4j_ok:
+    # Mostra mensagem do usuário
+    with st.chat_message("user", avatar="🧑"):
+        st.markdown(pergunta)
+    st.session_state.messages.append({"role": "user", "content": pergunta})
+
+    # Cria agente e responde
+    agent = criar_agente(get_openai_key())
+    if agent:
+        with st.chat_message("assistant", avatar="🤖"):
+            with st.spinner("Consultando grafo Neo4j..."):
+                try:
+                    resultado = agent.responder(pergunta)
+
+                    with st.expander(
+                        f"🔍 Cypher gerado ({len(resultado['resultados'])} resultados)",
+                        expanded=False
+                    ):
+                        st.code(resultado["cypher"], language="cypher")
+
+                    st.markdown(resultado["resposta"])
+
+                    st.session_state.messages.append({
+                        "role":         "assistant",
+                        "content":      resultado["resposta"],
+                        "cypher":       resultado["cypher"],
+                        "n_resultados": len(resultado["resultados"]),
+                    })
+                except Exception as e:
+                    msg_erro = f"Erro ao processar: {e}"
+                    st.error(msg_erro)
+                    st.session_state.messages.append({
+                        "role": "assistant", "content": msg_erro})
+    else:
+        st.error("Não foi possível criar o agente. Verifique as configurações.")
+
+elif pergunta and not get_openai_key():
+    st.warning("Configure a OpenAI API Key na sidebar.")
+elif pergunta and not st.session_state.neo4j_ok:
+    st.error("Neo4j não conectado.")