Upload 77 files

app/api/routes/entities.py

@@ -1,57 +1,162 @@
-"""
-Entity CRUD Routes
-"""
-from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy.orm import Session
-from sqlalchemy import or_
-from typing import List, Optional
-
-from app.api.deps import get_scoped_db
-from app.models import Entity, Relationship
-from app.schemas import EntityCreate, EntityUpdate, EntityResponse, GraphData, GraphNode, GraphEdge
-
-router = APIRouter(prefix="/entities", tags=["Entities"])
-
-
-@router.get("", response_model=List[EntityResponse])
-def list_entities(
-    type: Optional[str] = None,
-    search: Optional[str] = None,
-    project_id: Optional[str] = None,
-    limit: int = Query(default=50, le=200),
-    offset: int = 0,
-    db: Session = Depends(get_scoped_db)
-):
-    """Lista todas as entidades com filtros opcionais"""
-    query = db.query(Entity)
-    
-    if project_id:
-        query = query.filter(Entity.project_id == project_id)
-    
-    if type:
-        query = query.filter(Entity.type == type)
-    
-    if search:
-        query = query.filter(
-            or_(
-                Entity.name.ilike(f"%{search}%"),
-                Entity.description.ilike(f"%{search}%")
-            )
-        )
-    
-    query = query.order_by(Entity.created_at.desc())
-    return query.offset(offset).limit(limit).all()
+"""
+Entity CRUD Routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+from typing import List, Optional
+
+from app.api.deps import get_scoped_db
+from app.models import Entity, Relationship
+from app.schemas import EntityCreate, EntityUpdate, EntityResponse, GraphData, GraphNode, GraphEdge
+
+router = APIRouter(prefix="/entities", tags=["Entities"])
 
 
-@router.get("/types")
-def get_entity_types(db: Session = Depends(get_scoped_db)):
+@router.get("", response_model=List[EntityResponse])
+def list_entities(
+    type: Optional[str] = None,
+    search: Optional[str] = None,
+    project_id: Optional[str] = None,
+    limit: int = Query(default=50, le=200),
+    offset: int = 0,
+    db: Session = Depends(get_scoped_db)
+):
+    """Lista todas as entidades com filtros opcionais"""
+    query = db.query(Entity)
+    
+    if project_id:
+        query = query.filter(Entity.project_id == project_id)
+    
+    if type:
+        query = query.filter(Entity.type == type)
+    
+    if search:
+        query = query.filter(
+            or_(
+                Entity.name.ilike(f"%{search}%"),
+                Entity.description.ilike(f"%{search}%")
+            )
+        )
+    
+    query = query.order_by(Entity.created_at.desc())
+    return query.offset(offset).limit(limit).all()
+
+
+@router.get("/types")
+def get_entity_types(db: Session = Depends(get_scoped_db)):
     """Retorna todos os tipos de entidade únicos"""
     types = db.query(Entity.type).distinct().all()
     return [t[0] for t in types]
 
 
-@router.get("/{entity_id}", response_model=EntityResponse)
-def get_entity(entity_id: str, db: Session = Depends(get_scoped_db)):
+@router.get("/suggest-merge")
+async def suggest_merge_candidates(
+    limit: int = Query(default=10, le=50),
+    db: Session = Depends(get_scoped_db)
+):
+    """
+    Use LLM to find potential duplicate entities that could be merged.
+    Returns pairs of entities that might be the same.
+    """
+    import httpx
+    import json
+    import re
+    from app.config import settings
+    
+    # Get all entities
+    entities = db.query(Entity).order_by(Entity.name).limit(200).all()
+    
+    if len(entities) < 2:
+        return {"candidates": [], "message": "Not enough entities to compare"}
+    
+    # Build entity list for LLM
+    entity_list = []
+    for e in entities:
+        aliases = (e.properties or {}).get("aliases", [])
+        entity_list.append({
+            "id": e.id,
+            "name": e.name,
+            "type": e.type,
+            "aliases": aliases[:5] if aliases else []
+        })
+    
+    # Ask LLM to find duplicates
+    prompt = f"""Analise esta lista de entidades e encontre possíveis DUPLICATAS (mesma pessoa/organização/local com nomes diferentes).
+
+Entidades:
+{entity_list[:100]}
+
+Retorne APENAS um JSON válido com pares de IDs que são provavelmente a mesma entidade:
+```json
+{{
+  "duplicates": [
+    {{
+      "id1": "uuid1",
+      "id2": "uuid2", 
+      "confidence": 0.95,
+      "reason": "Mesmo nome com variação"
+    }}
+  ]
+}}
+```
+
+Se não houver duplicatas, retorne: {{"duplicates": []}}
+"""
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(
+                "https://api.cerebras.ai/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.cerebras_api_key}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": "zai-glm-4.7",
+                    "messages": [
+                        {"role": "system", "content": "Você é um especialista em detecção de entidades duplicadas. Responda apenas em JSON válido."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    "temperature": 0.1,
+                    "max_tokens": 1024
+                }
+            )
+            
+            if response.status_code != 200:
+                return {"candidates": [], "error": "LLM API error"}
+            
+            data = response.json()
+            content = data["choices"][0]["message"]["content"]
+            
+            # Parse JSON from response
+            json_match = re.search(r'\{.*\}', content, re.DOTALL)
+            if json_match:
+                result = json.loads(json_match.group(0))
+                
+                # Enrich with entity names
+                candidates = []
+                for dup in result.get("duplicates", [])[:limit]:
+                    e1 = next((e for e in entities if e.id == dup.get("id1")), None)
+                    e2 = next((e for e in entities if e.id == dup.get("id2")), None)
+                    if e1 and e2:
+                        candidates.append({
+                            "entity1": {"id": e1.id, "name": e1.name, "type": e1.type},
+                            "entity2": {"id": e2.id, "name": e2.name, "type": e2.type},
+                            "confidence": dup.get("confidence", 0.5),
+                            "reason": dup.get("reason", "Possível duplicata")
+                        })
+                
+                return {"candidates": candidates}
+            
+            return {"candidates": [], "message": "No duplicates found"}
+            
+    except Exception as e:
+        return {"candidates": [], "error": str(e)}
+
+
+@router.get("/{entity_id}", response_model=EntityResponse)
+def get_entity(entity_id: str, db: Session = Depends(get_scoped_db)):
     """Busca uma entidade por ID"""
     entity = db.query(Entity).filter(Entity.id == entity_id).first()
     if not entity:
@@ -59,8 +164,8 @@ def get_entity(entity_id: str, db: Session = Depends(get_scoped_db)):
     return entity
 
 
-@router.post("", response_model=EntityResponse, status_code=201)
-def create_entity(entity: EntityCreate, db: Session = Depends(get_scoped_db)):
+@router.post("", response_model=EntityResponse, status_code=201)
+def create_entity(entity: EntityCreate, db: Session = Depends(get_scoped_db)):
     """Cria uma nova entidade"""
     db_entity = Entity(**entity.model_dump())
     db.add(db_entity)
@@ -69,8 +174,8 @@ def create_entity(entity: EntityCreate, db: Session = Depends(get_scoped_db)):
     return db_entity
 
 
-@router.put("/{entity_id}", response_model=EntityResponse)
-def update_entity(entity_id: str, entity: EntityUpdate, db: Session = Depends(get_scoped_db)):
+@router.put("/{entity_id}", response_model=EntityResponse)
+def update_entity(entity_id: str, entity: EntityUpdate, db: Session = Depends(get_scoped_db)):
     """Atualiza uma entidade existente"""
     db_entity = db.query(Entity).filter(Entity.id == entity_id).first()
     if not db_entity:
@@ -85,8 +190,8 @@ def update_entity(entity_id: str, entity: EntityUpdate, db: Session = Depends(ge
     return db_entity
 
 
-@router.delete("/{entity_id}")
-def delete_entity(entity_id: str, db: Session = Depends(get_scoped_db)):
+@router.delete("/{entity_id}")
+def delete_entity(entity_id: str, db: Session = Depends(get_scoped_db)):
     """Deleta uma entidade"""
     db_entity = db.query(Entity).filter(Entity.id == entity_id).first()
     if not db_entity:
@@ -105,12 +210,12 @@ def delete_entity(entity_id: str, db: Session = Depends(get_scoped_db)):
     return {"message": "Entity deleted"}
 
 
-@router.get("/{entity_id}/connections", response_model=GraphData)
-def get_entity_connections(
-    entity_id: str,
-    depth: int = Query(default=1, le=3),
-    db: Session = Depends(get_scoped_db)
-):
+@router.get("/{entity_id}/connections", response_model=GraphData)
+def get_entity_connections(
+    entity_id: str,
+    depth: int = Query(default=1, le=3),
+    db: Session = Depends(get_scoped_db)
+):
     """
     Retorna o grafo de conexões de uma entidade
     Usado para visualização de rede no frontend
@@ -167,12 +272,12 @@ def get_entity_connections(
     )
 
 
-@router.post("/merge")
-def merge_entities(
-    primary_id: str,
-    secondary_id: str,
-    db: Session = Depends(get_scoped_db)
-):
+@router.post("/merge")
+def merge_entities(
+    primary_id: str,
+    secondary_id: str,
+    db: Session = Depends(get_scoped_db)
+):
     """
     Merge two entities into one.
     The primary entity is kept, the secondary is deleted.
@@ -246,108 +351,3 @@ def merge_entities(
         }
     }
 
-
-@router.get("/suggest-merge")
-async def suggest_merge_candidates(
-    limit: int = Query(default=10, le=50),
-    db: Session = Depends(get_scoped_db)
-):
-    """
-    Use LLM to find potential duplicate entities that could be merged.
-    Returns pairs of entities that might be the same.
-    """
-    import httpx
-    from app.config import settings
-    
-    # Get all entities
-    entities = db.query(Entity).order_by(Entity.name).limit(200).all()
-    
-    if len(entities) < 2:
-        return {"candidates": [], "message": "Not enough entities to compare"}
-    
-    # Build entity list for LLM
-    entity_list = []
-    for e in entities:
-        aliases = (e.properties or {}).get("aliases", [])
-        entity_list.append({
-            "id": e.id,
-            "name": e.name,
-            "type": e.type,
-            "aliases": aliases[:5] if aliases else []  # Limit aliases
-        })
-    
-    # Ask LLM to find duplicates
-    prompt = f"""Analise esta lista de entidades e encontre possíveis DUPLICATAS (mesma pessoa/organização/local com nomes diferentes).
-
-Entidades:
-{entity_list[:100]}
-
-Retorne APENAS um JSON válido com pares de IDs que são provavelmente a mesma entidade:
-```json
-{{
-  "duplicates": [
-    {{
-      "id1": "uuid1",
-      "id2": "uuid2", 
-      "confidence": 0.95,
-      "reason": "Mesmo nome com variação"
-    }}
-  ]
-}}
-```
-
-Se não houver duplicatas, retorne: {{"duplicates": []}}
-"""
-    
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(
-                "https://api.cerebras.ai/v1/chat/completions",
-                headers={
-                    "Authorization": f"Bearer {settings.cerebras_api_key}",
-                    "Content-Type": "application/json"
-                },
-                json={
-                    "model": "qwen-3-235b-a22b-instruct-2507",
-                    "messages": [
-                        {"role": "system", "content": "Você é um especialista em detecção de entidades duplicadas. Responda apenas em JSON válido."},
-                        {"role": "user", "content": prompt}
-                    ],
-                    "temperature": 0.1,
-                    "max_tokens": 1024
-                }
-            )
-            
-            if response.status_code != 200:
-                return {"candidates": [], "error": "LLM API error"}
-            
-            data = response.json()
-            content = data["choices"][0]["message"]["content"]
-            
-            # Parse JSON from response
-            import json
-            import re
-            json_match = re.search(r'\{.*\}', content, re.DOTALL)
-            if json_match:
-                result = json.loads(json_match.group(0))
-                
-                # Enrich with entity names
-                candidates = []
-                for dup in result.get("duplicates", [])[:limit]:
-                    e1 = next((e for e in entities if e.id == dup.get("id1")), None)
-                    e2 = next((e for e in entities if e.id == dup.get("id2")), None)
-                    if e1 and e2:
-                        candidates.append({
-                            "entity1": {"id": e1.id, "name": e1.name, "type": e1.type},
-                            "entity2": {"id": e2.id, "name": e2.name, "type": e2.type},
-                            "confidence": dup.get("confidence", 0.5),
-                            "reason": dup.get("reason", "Possível duplicata")
-                        })
-                
-                return {"candidates": candidates}
-            
-            return {"candidates": [], "message": "No duplicates found"}
-            
-    except Exception as e:
-        return {"candidates": [], "error": str(e)}
-