Update graph_agent.py

graph_agent.py

@@ -1,194 +1,152 @@
-# graph_knowledge.py — Popula Neo4j com base de conhecimento dos projetos
-CYPHER_SCHEMA = """
-// ── NÓS ──────────────────────────────────────────────────────
-
-// Projetos
-MERGE (p1:Projeto {nome: 'Sistema Imune Digital'})
-SET p1.descricao = 'Sistema de detecção de fraude bancária com Deep RL. Agente DQN Dueling com 3 agentes especialistas orquestrados.',
-    p1.paradigma = 'Deep Reinforcement Learning',
-    p1.dado = 'Sintético',
-    p1.url = 'https://huggingface.co/spaces/Danielfonseca1212/sistema-imune',
-    p1.emoji = '🛡️',
-    p1.ano = 2024;
-
-MERGE (p2:Projeto {nome: 'HetGNN Fraud'})
-SET p2.descricao = 'Heterogeneous Graph Neural Network com 5 tipos de nó e 7 tipos de aresta. HGTConv aprende atenção separada por tipo de relação.',
-    p2.paradigma = 'Supervised GNN',
-    p2.dado = 'Sintético',
-    p2.url = 'https://huggingface.co/spaces/Danielfonseca1212/hetgnn-fraud',
-    p2.emoji = '🕸️',
-    p2.ano = 2024;
-
-MERGE (p3:Projeto {nome: 'TGN Fraud Detection'})
-SET p3.descricao = 'Temporal Graph Network com memória evolutiva por nó via GRU. Detecta fraude em stream de e-commerce em tempo real.',
-    p3.paradigma = 'Temporal GNN',
-    p3.dado = 'Sintético',
-    p3.url = 'https://huggingface.co/spaces/Danielfonseca1212/tgn-fraud',
-    p3.emoji = '⏱️',
-    p3.ano = 2024;
-
-MERGE (p4:Projeto {nome: 'DOMINANT'})
-SET p4.descricao = 'Deep Anomaly Detection on Attributed Networks (IJCAI 2019). Detecta anomalias em grafo sem nenhum label no treino.',
-    p4.paradigma = 'Unsupervised GNN',
-    p4.dado = 'Sintético',
-    p4.url = 'https://huggingface.co/spaces/Danielfonseca1212/dominant-anomaly',
-    p4.emoji = '🔬',
-    p4.ano = 2024;
-
-MERGE (p5:Projeto {nome: 'GraphSAGE Elliptic'})
-SET p5.descricao = 'GraphSAGE inductive vs GCN vs MLP no dataset Elliptic Bitcoin real (MIT). 203k transações reais com split temporal.',
-    p5.paradigma = 'Inductive GNN',
-    p5.dado = 'Real',
-    p5.url = 'https://huggingface.co/spaces/Danielfonseca1212/elliptic-graphsage',
-    p5.emoji = '₿',
-    p5.ano = 2024;
-
-// Tecnologias
-MERGE (t1:Tecnologia {nome: 'PyTorch'});
-MERGE (t2:Tecnologia {nome: 'PyTorch Geometric'});
-MERGE (t3:Tecnologia {nome: 'Neo4j Aura'});
-MERGE (t4:Tecnologia {nome: 'Streamlit'});
-MERGE (t5:Tecnologia {nome: 'DQN Dueling'});
-MERGE (t6:Tecnologia {nome: 'HGTConv'});
-MERGE (t7:Tecnologia {nome: 'SAGEConv'});
-MERGE (t8:Tecnologia {nome: 'GCNConv'});
-MERGE (t9:Tecnologia {nome: 'GRU Memory'});
-MERGE (t10:Tecnologia {nome: 'Time2Vec'});
-MERGE (t11:Tecnologia {nome: 'GCN Encoder'});
-MERGE (t12:Tecnologia {nome: 'Autoencoder'});
-MERGE (t13:Tecnologia {nome: 'GraphSAGE'});
-MERGE (t14:Tecnologia {nome: 'Hugging Face Spaces'});
-MERGE (t15:Tecnologia {nome: 'OpenAI GPT'});
-MERGE (t16:Tecnologia {nome: 'Cypher'});
-
-// Conceitos
-MERGE (c1:Conceito {nome: 'Detecção de Fraude'})
-SET c1.descricao = 'Identificação automática de transações fraudulentas em sistemas financeiros.';
-MERGE (c2:Conceito {nome: 'Graph Neural Network'})
-SET c2.descricao = 'Redes neurais que operam diretamente em dados estruturados como grafos.';
-MERGE (c3:Conceito {nome: 'Aprendizado por Reforço'})
-SET c3.descricao = 'Paradigma onde agente aprende por tentativa e erro maximizando recompensa.';
-MERGE (c4:Conceito {nome: 'Grafo Heterogêneo'})
-SET c4.descricao = 'Grafo com múltiplos tipos de nó e aresta, cada um com semântica diferente.';
-MERGE (c5:Conceito {nome: 'Grafo Temporal'})
-SET c5.descricao = 'Grafo que evolui no tempo, com eventos ordenados temporalmente.';
-MERGE (c6:Conceito {nome: 'Anomaly Detection'})
-SET c6.descricao = 'Detecção de padrões incomuns sem necessidade de labels supervisionados.';
-MERGE (c7:Conceito {nome: 'Inductive Learning'})
-SET c7.descricao = 'Modelo que generaliza para nós/grafos novos sem retreinar.';
-MERGE (c8:Conceito {nome: 'Message Passing'})
-SET c8.descricao = 'Mecanismo onde nós agregam informação dos vizinhos iterativamente.';
-MERGE (c9:Conceito {nome: 'Attention Mechanism'})
-SET c9.descricao = 'Pesos aprendidos que determinam a importância de cada vizinho.';
-MERGE (c10:Conceito {nome: 'Memory Module'})
-SET c10.descricao = 'Vetor de estado por nó que acumula histórico de interações.';
-MERGE (c11:Conceito {nome: 'Node Classification'})
-SET c11.descricao = 'Tarefa de prever a classe de cada nó no grafo.';
-MERGE (c12:Conceito {nome: 'Unsupervised Learning'})
-SET c12.descricao = 'Aprendizado sem labels — modelo descobre estrutura nos dados.';
-
-// Papers
-MERGE (pp1:Paper {titulo: 'Human-level control through deep reinforcement learning'})
-SET pp1.autores = 'Mnih et al.', pp1.venue = 'Nature 2015', pp1.modelo = 'DQN';
-MERGE (pp2:Paper {titulo: 'Heterogeneous Graph Transformer'})
-SET pp2.autores = 'Hu et al.', pp2.venue = 'WWW 2020', pp2.modelo = 'HGT';
-MERGE (pp3:Paper {titulo: 'Temporal Graph Networks'})
-SET pp3.autores = 'Rossi et al.', pp3.venue = 'ICML 2020', pp3.modelo = 'TGN';
-MERGE (pp4:Paper {titulo: 'Deep Anomaly Detection on Attributed Networks'})
-SET pp4.autores = 'Ding et al.', pp4.venue = 'IJCAI 2019', pp4.modelo = 'DOMINANT';
-MERGE (pp5:Paper {titulo: 'Inductive Representation Learning on Large Graphs'})
-SET pp5.autores = 'Hamilton et al.', pp5.venue = 'NeurIPS 2017', pp5.modelo = 'GraphSAGE';
-
-// Métricas (aproximadas — baseadas em dados sintéticos)
-MERGE (m1:Metrica {projeto: 'HetGNN Fraud', tipo: 'AUC'})
-SET m1.valor = 0.89, m1.dataset = 'Sintético';
-MERGE (m2:Metrica {projeto: 'TGN Fraud Detection', tipo: 'AUC'})
-SET m2.valor = 0.91, m2.dataset = 'Sintético';
-MERGE (m3:Metrica {projeto: 'DOMINANT', tipo: 'AUC'})
-SET m3.valor = 0.84, m3.dataset = 'Sintético';
-MERGE (m4:Metrica {projeto: 'GraphSAGE Elliptic', tipo: 'AUC'})
-SET m4.valor = 0.97, m4.dataset = 'Elliptic Bitcoin Real';
-
-// ── ARESTAS ───────────────────────────────────────────────────
-
-// Projetos USAM tecnologias
-MATCH (p:Projeto {nome:'Sistema Imune Digital'}), (t:Tecnologia {nome:'PyTorch'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'Sistema Imune Digital'}), (t:Tecnologia {nome:'DQN Dueling'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'Sistema Imune Digital'}), (t:Tecnologia {nome:'Neo4j Aura'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'Sistema Imune Digital'}), (t:Tecnologia {nome:'Streamlit'}) MERGE (p)-[:USA]->(t);
-
-MATCH (p:Projeto {nome:'HetGNN Fraud'}), (t:Tecnologia {nome:'PyTorch Geometric'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'HetGNN Fraud'}), (t:Tecnologia {nome:'HGTConv'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'HetGNN Fraud'}), (t:Tecnologia {nome:'Neo4j Aura'}) MERGE (p)-[:USA]->(t);
-
-MATCH (p:Projeto {nome:'TGN Fraud Detection'}), (t:Tecnologia {nome:'GRU Memory'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'TGN Fraud Detection'}), (t:Tecnologia {nome:'Time2Vec'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'TGN Fraud Detection'}), (t:Tecnologia {nome:'PyTorch'}) MERGE (p)-[:USA]->(t);
-
-MATCH (p:Projeto {nome:'DOMINANT'}), (t:Tecnologia {nome:'GCN Encoder'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'DOMINANT'}), (t:Tecnologia {nome:'Autoencoder'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'DOMINANT'}), (t:Tecnologia {nome:'PyTorch Geometric'}) MERGE (p)-[:USA]->(t);
-
-MATCH (p:Projeto {nome:'GraphSAGE Elliptic'}), (t:Tecnologia {nome:'GraphSAGE'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'GraphSAGE Elliptic'}), (t:Tecnologia {nome:'SAGEConv'}) MERGE (p)-[:USA]->(t);
-MATCH (p:Projeto {nome:'GraphSAGE Elliptic'}), (t:Tecnologia {nome:'GCNConv'}) MERGE (p)-[:USA]->(t);
-
-// Projetos IMPLEMENTAM conceitos
-MATCH (p:Projeto {nome:'Sistema Imune Digital'}), (c:Conceito {nome:'Aprendizado por Reforço'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'Sistema Imune Digital'}), (c:Conceito {nome:'Detecção de Fraude'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'HetGNN Fraud'}), (c:Conceito {nome:'Grafo Heterogêneo'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'HetGNN Fraud'}), (c:Conceito {nome:'Attention Mechanism'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'HetGNN Fraud'}), (c:Conceito {nome:'Node Classification'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'TGN Fraud Detection'}), (c:Conceito {nome:'Grafo Temporal'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'TGN Fraud Detection'}), (c:Conceito {nome:'Memory Module'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'DOMINANT'}), (c:Conceito {nome:'Anomaly Detection'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'DOMINANT'}), (c:Conceito {nome:'Unsupervised Learning'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'GraphSAGE Elliptic'}), (c:Conceito {nome:'Inductive Learning'}) MERGE (p)-[:IMPLEMENTA]->(c);
-MATCH (p:Projeto {nome:'GraphSAGE Elliptic'}), (c:Conceito {nome:'Message Passing'}) MERGE (p)-[:IMPLEMENTA]->(c);
-
-// Projetos REFERENCIAM papers
-MATCH (p:Projeto {nome:'Sistema Imune Digital'}), (pp:Paper {modelo:'DQN'}) MERGE (p)-[:REFERENCIA]->(pp);
-MATCH (p:Projeto {nome:'HetGNN Fraud'}), (pp:Paper {modelo:'HGT'}) MERGE (p)-[:REFERENCIA]->(pp);
-MATCH (p:Projeto {nome:'TGN Fraud Detection'}), (pp:Paper {modelo:'TGN'}) MERGE (p)-[:REFERENCIA]->(pp);
-MATCH (p:Projeto {nome:'DOMINANT'}), (pp:Paper {modelo:'DOMINANT'}) MERGE (p)-[:REFERENCIA]->(pp);
-MATCH (p:Projeto {nome:'GraphSAGE Elliptic'}), (pp:Paper {modelo:'GraphSAGE'}) MERGE (p)-[:REFERENCIA]->(pp);
-
-// Projetos TEM métricas
-MATCH (p:Projeto {nome:'HetGNN Fraud'}), (m:Metrica {projeto:'HetGNN Fraud'}) MERGE (p)-[:TEM_METRICA]->(m);
-MATCH (p:Projeto {nome:'TGN Fraud Detection'}), (m:Metrica {projeto:'TGN Fraud Detection'}) MERGE (p)-[:TEM_METRICA]->(m);
-MATCH (p:Projeto {nome:'DOMINANT'}), (m:Metrica {projeto:'DOMINANT'}) MERGE (p)-[:TEM_METRICA]->(m);
-MATCH (p:Projeto {nome:'GraphSAGE Elliptic'}), (m:Metrica {projeto:'GraphSAGE Elliptic'}) MERGE (p)-[:TEM_METRICA]->(m);
-
-// DIFERENTE_DE (para comparação)
-MATCH (p1:Projeto {nome:'DOMINANT'}), (p2:Projeto {nome:'HetGNN Fraud'})
-MERGE (p1)-[:DIFERENTE_DE {motivo: 'DOMINANT não usa labels, HetGNN usa supervisão'}]->(p2);
-MATCH (p1:Projeto {nome:'GraphSAGE Elliptic'}), (p2:Projeto {nome:'HetGNN Fraud'})
-MERGE (p1)-[:DIFERENTE_DE {motivo: 'GraphSAGE é inductive, HetGNN é transductive'}]->(p2);
-"""
-
-def popular_neo4j(driver, database):
-    """Executa o schema Cypher para popular a base de conhecimento."""
-    statements = [s.strip() for s in CYPHER_SCHEMA.split(';') if s.strip()]
-    erros = []
-    with driver.session(database=database) as session:
-        for stmt in statements:
-            try:
-                session.run(stmt)
-            except Exception as e:
-                erros.append(str(e))
-    return len(statements), erros
-
-def verificar_schema(driver, database):
-    """Retorna contagem de nós e arestas por tipo."""
-    with driver.session(database=database) as session:
-        nos = session.run("""
-            MATCH (n) 
-            RETURN labels(n)[0] AS tipo, count(n) AS total
-            ORDER BY total DESC
-        """).data()
-        arestas = session.run("""
-            MATCH ()-[r]->()
-            RETURN type(r) AS tipo, count(r) AS total
-            ORDER BY total DESC
-        """).data()
-    return nos, arestas
+# 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,
+        }