Upload 55 files

app/api/routes/investigate.py

@@ -0,0 +1,123 @@
+"""
+Investigation API Routes - Build dossiers on companies and people
+"""
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+
+from app.services.investigation import (
+    investigar_empresa,
+    investigar_pessoa,
+    dossier_to_dict
+)
+from app.services.brazil_apis import consultar_cnpj
+
+
+router = APIRouter(prefix="/investigate", tags=["Investigation"])
+
+
+class InvestigateCompanyRequest(BaseModel):
+    """Request to investigate a company"""
+    cnpj: str = Field(..., min_length=11, description="CNPJ da empresa")
+
+
+class InvestigatePersonRequest(BaseModel):
+    """Request to investigate a person"""
+    nome: str = Field(..., min_length=2, description="Nome da pessoa")
+    cpf: Optional[str] = Field(None, description="CPF (opcional)")
+
+
+class DossierResponse(BaseModel):
+    """Dossier response"""
+    tipo: str
+    alvo: str
+    cnpj_cpf: Optional[str]
+    red_flags: List[str]
+    score_risco: int
+    data_geracao: str
+    fonte_dados: List[str]
+    secoes: Dict[str, Any]
+
+
+class CNPJResponse(BaseModel):
+    """Quick CNPJ lookup response"""
+    cnpj: str
+    razao_social: str
+    nome_fantasia: str
+    situacao: str
+    data_abertura: str
+    capital_social: float
+    endereco: str
+    telefone: str
+    email: str
+    atividade: str
+    socios: List[Dict[str, Any]]
+
+
+@router.post("/company", response_model=DossierResponse)
+async def investigate_company(request: InvestigateCompanyRequest):
+    """
+    Build a comprehensive dossier on a company.
+    
+    Collects:
+    - Cadastral data from CNPJ
+    - Partners/owners
+    - Sanctions (CEIS, CNEP, CEPIM)
+    - News and media mentions
+    - Related entities
+    
+    Returns risk score and red flags.
+    """
+    try:
+        dossier = await investigar_empresa(request.cnpj)
+        return DossierResponse(**dossier_to_dict(dossier))
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/person", response_model=DossierResponse)
+async def investigate_person(request: InvestigatePersonRequest):
+    """
+    Build a dossier on a person.
+    
+    Note: Due to LGPD, personal data is limited.
+    Mainly uses web search for public information.
+    """
+    try:
+        dossier = await investigar_pessoa(request.nome, request.cpf)
+        return DossierResponse(**dossier_to_dict(dossier))
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/cnpj/{cnpj}", response_model=CNPJResponse)
+async def lookup_cnpj(cnpj: str):
+    """
+    Quick CNPJ lookup - returns basic company data.
+    """
+    try:
+        data = await consultar_cnpj(cnpj)
+        
+        if not data:
+            raise HTTPException(status_code=404, detail="CNPJ não encontrado")
+        
+        return CNPJResponse(
+            cnpj=data.cnpj,
+            razao_social=data.razao_social,
+            nome_fantasia=data.nome_fantasia,
+            situacao=data.situacao,
+            data_abertura=data.data_abertura,
+            capital_social=data.capital_social,
+            endereco=f"{data.logradouro}, {data.numero} - {data.bairro}, {data.cidade}/{data.uf}",
+            telefone=data.telefone,
+            email=data.email,
+            atividade=f"{data.cnae_principal} - {data.cnae_descricao}",
+            socios=data.socios
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/main.py

@@ -8,7 +8,7 @@ from contextlib import asynccontextmanager
 
 from app.config import settings
 from app.core.database import init_db
-from app.api.routes import entities, relationships, events, search, ingest, analyze, graph, research, chat
+from app.api.routes import entities, relationships, events, search, ingest, analyze, graph, research, chat, investigate
 
 
 @asynccontextmanager
@@ -59,6 +59,7 @@ app.include_router(analyze.router, prefix="/api/v1")
 app.include_router(graph.router, prefix="/api/v1")
 app.include_router(research.router, prefix="/api/v1")
 app.include_router(chat.router, prefix="/api/v1")
+app.include_router(investigate.router, prefix="/api/v1")
 
 
 @app.get("/")

app/services/brazil_apis.py

@@ -0,0 +1,218 @@
+"""
+Brazilian Data APIs Service
+Consolidates access to public Brazilian data APIs for investigation
+"""
+import httpx
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass, field
+import re
+
+
+# API URLs
+CNPJA_URL = "https://api.cnpja.com.br/office"
+OPENCNPJ_URL = "https://api.opencnpj.org/v1/cnpj"
+BRASILAPI_CNPJ = "https://brasilapi.com.br/api/cnpj/v1"
+BRASILAPI_CEP = "https://brasilapi.com.br/api/cep/v2"
+
+
+@dataclass
+class CompanyData:
+    """Data structure for company information"""
+    cnpj: str
+    razao_social: str = ""
+    nome_fantasia: str = ""
+    situacao: str = ""
+    data_abertura: str = ""
+    natureza_juridica: str = ""
+    capital_social: float = 0.0
+    porte: str = ""
+    
+    # Address
+    logradouro: str = ""
+    numero: str = ""
+    complemento: str = ""
+    bairro: str = ""
+    cidade: str = ""
+    uf: str = ""
+    cep: str = ""
+    
+    # Contact
+    telefone: str = ""
+    email: str = ""
+    
+    # Activity
+    cnae_principal: str = ""
+    cnae_descricao: str = ""
+    cnaes_secundarios: List[str] = field(default_factory=list)
+    
+    # Partners/Owners
+    socios: List[Dict[str, Any]] = field(default_factory=list)
+    
+    # Source
+    fonte: str = ""
+
+
+def clean_cnpj(cnpj: str) -> str:
+    """Remove formatting from CNPJ"""
+    return re.sub(r'[^0-9]', '', cnpj)
+
+
+async def consultar_cnpj(cnpj: str) -> Optional[CompanyData]:
+    """
+    Query CNPJ data from available APIs.
+    Tries BrasilAPI first (more reliable), then falls back to others.
+    """
+    cnpj_clean = clean_cnpj(cnpj)
+    
+    if len(cnpj_clean) != 14:
+        return None
+    
+    # Try BrasilAPI first
+    result = await _query_brasilapi(cnpj_clean)
+    if result:
+        return result
+    
+    # Fallback to OpenCNPJ
+    result = await _query_opencnpj(cnpj_clean)
+    if result:
+        return result
+    
+    return None
+
+
+async def _query_brasilapi(cnpj: str) -> Optional[CompanyData]:
+    """Query BrasilAPI for CNPJ data"""
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(f"{BRASILAPI_CNPJ}/{cnpj}")
+            
+            if response.status_code != 200:
+                return None
+            
+            data = response.json()
+            
+            # Parse partners
+            socios = []
+            for socio in data.get("qsa", []):
+                socios.append({
+                    "nome": socio.get("nome_socio", ""),
+                    "qualificacao": socio.get("qualificacao_socio", ""),
+                    "cpf_cnpj": socio.get("cnpj_cpf_do_socio", ""),
+                    "data_entrada": socio.get("data_entrada_sociedade", "")
+                })
+            
+            # Parse CNAEs
+            cnaes_sec = []
+            for cnae in data.get("cnaes_secundarios", []):
+                if isinstance(cnae, dict):
+                    cnaes_sec.append(f"{cnae.get('codigo', '')} - {cnae.get('descricao', '')}")
+                else:
+                    cnaes_sec.append(str(cnae))
+            
+            return CompanyData(
+                cnpj=cnpj,
+                razao_social=data.get("razao_social", ""),
+                nome_fantasia=data.get("nome_fantasia", ""),
+                situacao=data.get("descricao_situacao_cadastral", ""),
+                data_abertura=data.get("data_inicio_atividade", ""),
+                natureza_juridica=data.get("natureza_juridica", ""),
+                capital_social=float(data.get("capital_social", 0)),
+                porte=data.get("porte", ""),
+                logradouro=data.get("logradouro", ""),
+                numero=data.get("numero", ""),
+                complemento=data.get("complemento", ""),
+                bairro=data.get("bairro", ""),
+                cidade=data.get("municipio", ""),
+                uf=data.get("uf", ""),
+                cep=data.get("cep", ""),
+                telefone=data.get("ddd_telefone_1", ""),
+                email=data.get("email", ""),
+                cnae_principal=str(data.get("cnae_fiscal", "")),
+                cnae_descricao=data.get("cnae_fiscal_descricao", ""),
+                cnaes_secundarios=cnaes_sec,
+                socios=socios,
+                fonte="BrasilAPI"
+            )
+            
+    except Exception as e:
+        print(f"BrasilAPI error: {e}")
+        return None
+
+
+async def _query_opencnpj(cnpj: str) -> Optional[CompanyData]:
+    """Query OpenCNPJ API"""
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(f"{OPENCNPJ_URL}/{cnpj}")
+            
+            if response.status_code != 200:
+                return None
+            
+            data = response.json()
+            
+            # Parse partners
+            socios = []
+            for socio in data.get("socios", []):
+                socios.append({
+                    "nome": socio.get("nome", ""),
+                    "qualificacao": socio.get("qualificacao", ""),
+                    "cpf_cnpj": "",
+                    "data_entrada": socio.get("data_entrada", "")
+                })
+            
+            return CompanyData(
+                cnpj=cnpj,
+                razao_social=data.get("razao_social", ""),
+                nome_fantasia=data.get("nome_fantasia", ""),
+                situacao=data.get("situacao_cadastral", ""),
+                data_abertura=data.get("data_inicio_atividade", ""),
+                natureza_juridica=data.get("natureza_juridica", ""),
+                capital_social=float(data.get("capital_social", 0) or 0),
+                porte=data.get("porte", ""),
+                logradouro=data.get("logradouro", ""),
+                numero=data.get("numero", ""),
+                complemento=data.get("complemento", ""),
+                bairro=data.get("bairro", ""),
+                cidade=data.get("municipio", ""),
+                uf=data.get("uf", ""),
+                cep=data.get("cep", ""),
+                telefone=data.get("telefone", ""),
+                email=data.get("email", ""),
+                cnae_principal=data.get("cnae_principal", {}).get("codigo", ""),
+                cnae_descricao=data.get("cnae_principal", {}).get("descricao", ""),
+                cnaes_secundarios=[],
+                socios=socios,
+                fonte="OpenCNPJ"
+            )
+            
+    except Exception as e:
+        print(f"OpenCNPJ error: {e}")
+        return None
+
+
+async def consultar_cep(cep: str) -> Optional[Dict[str, Any]]:
+    """Query address by CEP"""
+    cep_clean = re.sub(r'[^0-9]', '', cep)
+    
+    try:
+        async with httpx.AsyncClient(timeout=15.0) as client:
+            response = await client.get(f"{BRASILAPI_CEP}/{cep_clean}")
+            
+            if response.status_code != 200:
+                return None
+            
+            return response.json()
+            
+    except Exception as e:
+        print(f"CEP query error: {e}")
+        return None
+
+
+async def buscar_empresas_por_nome(nome: str, uf: Optional[str] = None) -> List[Dict[str, Any]]:
+    """
+    Search companies by name using web search (via Lancer).
+    This is a workaround since direct name search APIs are paid.
+    """
+    # This would need Lancer integration for web search
+    # For now, return empty - will be filled by investigation service
+    return []

app/services/investigation.py

@@ -0,0 +1,309 @@
+"""
+Investigation Service - Builds comprehensive dossiers
+Combines CNPJ data, transparency/sanctions, Lancer web search, and NER
+"""
+import httpx
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass, field, asdict
+import asyncio
+
+from app.services.brazil_apis import consultar_cnpj, CompanyData
+from app.services.transparencia_api import verificar_sancoes
+from app.services import lancer
+from app.services.nlp import entity_extractor
+from app.core.database import get_db
+from app.models.entity import Entity, Relationship
+
+
+LANCER_URL = "https://madras1-lancer.hf.space/api/v1"
+
+
+@dataclass
+class DossierSection:
+    """A section of the dossier"""
+    titulo: str
+    conteudo: Any
+    status: str = "ok"  # ok, warning, danger, info
+    icone: str = "📋"
+
+
+@dataclass
+class Dossier:
+    """Complete investigation dossier"""
+    tipo: str  # "organization" or "person"
+    alvo: str  # Target name
+    cnpj_cpf: Optional[str] = None
+    
+    # Sections
+    dados_cadastrais: Optional[DossierSection] = None
+    socios: Optional[DossierSection] = None
+    sancoes: Optional[DossierSection] = None
+    noticias: Optional[DossierSection] = None
+    entidades_relacionadas: Optional[DossierSection] = None
+    
+    # Metadata
+    red_flags: List[str] = field(default_factory=list)
+    score_risco: int = 0  # 0-100
+    data_geracao: str = ""
+    fonte_dados: List[str] = field(default_factory=list)
+
+
+async def investigar_empresa(nome_ou_cnpj: str) -> Dossier:
+    """
+    Investigate a company and build a comprehensive dossier.
+    """
+    import re
+    from datetime import datetime
+    
+    dossier = Dossier(
+        tipo="organization",
+        alvo=nome_ou_cnpj,
+        data_geracao=datetime.now().isoformat()
+    )
+    
+    # Check if input is CNPJ
+    cnpj_clean = re.sub(r'[^0-9]', '', nome_ou_cnpj)
+    is_cnpj = len(cnpj_clean) == 14
+    
+    company_data = None
+    
+    # 1. Get company data from CNPJ
+    if is_cnpj:
+        dossier.cnpj_cpf = cnpj_clean
+        company_data = await consultar_cnpj(cnpj_clean)
+        
+        if company_data:
+            dossier.alvo = company_data.razao_social or company_data.nome_fantasia or nome_ou_cnpj
+            dossier.fonte_dados.append(company_data.fonte)
+            
+            # Build cadastral section
+            dossier.dados_cadastrais = DossierSection(
+                titulo="Dados Cadastrais",
+                icone="🏢",
+                conteudo={
+                    "cnpj": company_data.cnpj,
+                    "razao_social": company_data.razao_social,
+                    "nome_fantasia": company_data.nome_fantasia,
+                    "situacao": company_data.situacao,
+                    "data_abertura": company_data.data_abertura,
+                    "natureza_juridica": company_data.natureza_juridica,
+                    "capital_social": company_data.capital_social,
+                    "porte": company_data.porte,
+                    "endereco": f"{company_data.logradouro}, {company_data.numero} - {company_data.bairro}, {company_data.cidade}/{company_data.uf}",
+                    "cep": company_data.cep,
+                    "telefone": company_data.telefone,
+                    "email": company_data.email,
+                    "atividade_principal": f"{company_data.cnae_principal} - {company_data.cnae_descricao}"
+                }
+            )
+            
+            # Check situação for red flags
+            if company_data.situacao and "ATIVA" not in company_data.situacao.upper():
+                dossier.red_flags.append(f"⚠️ Situação cadastral: {company_data.situacao}")
+                dossier.dados_cadastrais.status = "warning"
+            
+            # Build partners section
+            if company_data.socios:
+                dossier.socios = DossierSection(
+                    titulo=f"Sócios ({len(company_data.socios)})",
+                    icone="👥",
+                    conteudo=company_data.socios
+                )
+    
+    # 2. Check sanctions/transparency
+    if dossier.cnpj_cpf:
+        sancoes = await verificar_sancoes(dossier.cnpj_cpf)
+        dossier.fonte_dados.append("Portal da Transparência")
+        
+        if sancoes["tem_sancoes"]:
+            dossier.red_flags.append(f"🚨 Encontrado em {sancoes['total_sancoes']} lista(s) de sanções")
+            dossier.score_risco += 40
+            
+            dossier.sancoes = DossierSection(
+                titulo=f"Sanções ({sancoes['total_sancoes']})",
+                icone="⚠️",
+                status="danger",
+                conteudo=sancoes
+            )
+        else:
+            dossier.sancoes = DossierSection(
+                titulo="Sanções",
+                icone="✅",
+                status="ok",
+                conteudo={"mensagem": "Nenhuma sanção encontrada nos cadastros públicos"}
+            )
+    
+    # 3. Web search for news and context
+    search_query = dossier.alvo
+    if company_data and company_data.nome_fantasia:
+        search_query = company_data.nome_fantasia
+    
+    try:
+        web_result = await lancer.search(f"{search_query} notícias escândalos processos", max_results=8)
+        
+        if web_result.answer or web_result.results:
+            dossier.fonte_dados.append("Lancer Web Search")
+            
+            news_content = {
+                "resumo": web_result.answer or "Sem resumo disponível",
+                "fontes": [
+                    {"titulo": r.title, "url": r.url, "snippet": r.content[:200]}
+                    for r in web_result.results[:5]
+                ]
+            }
+            
+            dossier.noticias = DossierSection(
+                titulo="Notícias e Mídia",
+                icone="📰",
+                conteudo=news_content
+            )
+            
+            # Check for negative keywords in news
+            negative_keywords = ["escândalo", "fraude", "corrupção", "prisão", "investigado", "denúncia", "irregularidade"]
+            raw_text = (web_result.answer or "").lower()
+            for kw in negative_keywords:
+                if kw in raw_text:
+                    dossier.red_flags.append(f"📰 Menção a '{kw}' encontrada nas notícias")
+                    dossier.noticias.status = "warning"
+                    dossier.score_risco += 10
+                    break
+    except Exception as e:
+        print(f"Web search error: {e}")
+    
+    # 4. Extract related entities using NER
+    if dossier.noticias and dossier.noticias.conteudo.get("resumo"):
+        try:
+            text_to_analyze = dossier.noticias.conteudo.get("resumo", "")[:3000]
+            ner_result = await entity_extractor.extract(text_to_analyze)
+            
+            if ner_result.entities:
+                entities = [
+                    {"nome": e.name, "tipo": e.type, "descricao": e.description or e.role}
+                    for e in ner_result.entities[:10]
+                ]
+                
+                dossier.entidades_relacionadas = DossierSection(
+                    titulo=f"Entidades Relacionadas ({len(entities)})",
+                    icone="🔗",
+                    conteudo=entities
+                )
+        except Exception as e:
+            print(f"NER error: {e}")
+    
+    # Calculate final risk score
+    dossier.score_risco = min(100, dossier.score_risco + len(dossier.red_flags) * 5)
+    
+    return dossier
+
+
+async def investigar_pessoa(nome: str, cpf: Optional[str] = None) -> Dossier:
+    """
+    Investigate a person and build a dossier.
+    Note: CPF data is heavily protected by LGPD, so mainly uses web search.
+    """
+    from datetime import datetime
+    
+    dossier = Dossier(
+        tipo="person",
+        alvo=nome,
+        cnpj_cpf=cpf,
+        data_geracao=datetime.now().isoformat()
+    )
+    
+    # 1. Check sanctions if CPF provided
+    if cpf:
+        sancoes = await verificar_sancoes(cpf)
+        dossier.fonte_dados.append("Portal da Transparência")
+        
+        if sancoes["tem_sancoes"]:
+            dossier.red_flags.append(f"🚨 Encontrado em {sancoes['total_sancoes']} lista(s) de sanções")
+            dossier.score_risco += 50
+            
+            dossier.sancoes = DossierSection(
+                titulo=f"Sanções ({sancoes['total_sancoes']})",
+                icone="⚠️",
+                status="danger",
+                conteudo=sancoes
+            )
+    
+    # 2. Web search for information
+    try:
+        web_result = await lancer.search(f'"{nome}" biografia cargo empresa', max_results=10)
+        
+        if web_result.answer or web_result.results:
+            dossier.fonte_dados.append("Lancer Web Search")
+            
+            dossier.noticias = DossierSection(
+                titulo="Informações Públicas",
+                icone="🌐",
+                conteudo={
+                    "resumo": web_result.answer or "Informações limitadas",
+                    "fontes": [
+                        {"titulo": r.title, "url": r.url, "snippet": r.content[:200]}
+                        for r in web_result.results[:5]
+                    ]
+                }
+            )
+            
+            # Check for negative keywords
+            negative_keywords = ["preso", "condenado", "investigado", "acusado", "escândalo", "fraude"]
+            raw_text = (web_result.answer or "").lower()
+            for kw in negative_keywords:
+                if kw in raw_text:
+                    dossier.red_flags.append(f"📰 Menção a '{kw}' encontrada")
+                    dossier.noticias.status = "warning"
+                    dossier.score_risco += 15
+                    break
+    except Exception as e:
+        print(f"Web search error: {e}")
+    
+    # 3. Extract related entities
+    if dossier.noticias and dossier.noticias.conteudo.get("resumo"):
+        try:
+            ner_result = await entity_extractor.extract(dossier.noticias.conteudo["resumo"][:2000])
+            
+            if ner_result.entities:
+                entities = [
+                    {"nome": e.name, "tipo": e.type, "descricao": e.description or e.role}
+                    for e in ner_result.entities[:10]
+                    if e.name.lower() != nome.lower()  # Exclude the target
+                ]
+                
+                if entities:
+                    dossier.entidades_relacionadas = DossierSection(
+                        titulo=f"Conexões ({len(entities)})",
+                        icone="🔗",
+                        conteudo=entities
+                    )
+        except Exception as e:
+            print(f"NER error: {e}")
+    
+    dossier.score_risco = min(100, dossier.score_risco + len(dossier.red_flags) * 5)
+    
+    return dossier
+
+
+def dossier_to_dict(dossier: Dossier) -> Dict[str, Any]:
+    """Convert dossier to dictionary for JSON response"""
+    result = {
+        "tipo": dossier.tipo,
+        "alvo": dossier.alvo,
+        "cnpj_cpf": dossier.cnpj_cpf,
+        "red_flags": dossier.red_flags,
+        "score_risco": dossier.score_risco,
+        "data_geracao": dossier.data_geracao,
+        "fonte_dados": dossier.fonte_dados,
+        "secoes": {}
+    }
+    
+    for field_name in ["dados_cadastrais", "socios", "sancoes", "noticias", "entidades_relacionadas"]:
+        section = getattr(dossier, field_name)
+        if section:
+            result["secoes"][field_name] = {
+                "titulo": section.titulo,
+                "icone": section.icone,
+                "status": section.status,
+                "conteudo": section.conteudo
+            }
+    
+    return result

app/services/transparencia_api.py

@@ -0,0 +1,146 @@
+"""
+Portal da Transparência APIs
+Access to Brazilian government transparency data
+"""
+import httpx
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass
+
+
+# Portal da Transparência base URL
+TRANSPARENCIA_URL = "https://api.portaldatransparencia.gov.br/api-de-dados"
+
+
+@dataclass
+class SanctionRecord:
+    """Data structure for sanction/punishment records"""
+    tipo: str  # CEIS, CNEP, CEPIM
+    cpf_cnpj: str
+    nome: str
+    tipo_pessoa: str  # 'F' or 'J'
+    
+    # Sanction details
+    tipo_sancao: str = ""
+    data_inicio: str = ""
+    data_fim: str = ""
+    orgao_sancionador: str = ""
+    uf_orgao: str = ""
+    fundamentacao_legal: str = ""
+    
+    # Source
+    fonte_url: str = ""
+
+
+async def consultar_ceis(cnpj_cpf: str, token: Optional[str] = None) -> List[SanctionRecord]:
+    """
+    Query CEIS - Cadastro de Empresas Inidôneas e Suspensas
+    Note: Requires authentication token from Portal da Transparência
+    """
+    # Without token, we can still try - some endpoints work without auth
+    return await _query_sanctions("ceis", cnpj_cpf, token)
+
+
+async def consultar_cnep(cnpj_cpf: str, token: Optional[str] = None) -> List[SanctionRecord]:
+    """
+    Query CNEP - Cadastro Nacional de Empresas Punidas
+    """
+    return await _query_sanctions("cnep", cnpj_cpf, token)
+
+
+async def consultar_cepim(cnpj_cpf: str, token: Optional[str] = None) -> List[SanctionRecord]:
+    """
+    Query CEPIM - Cadastro de Entidades Privadas sem Fins Lucrativos Impedidas
+    """
+    return await _query_sanctions("cepim", cnpj_cpf, token)
+
+
+async def _query_sanctions(
+    endpoint: str, 
+    cnpj_cpf: str, 
+    token: Optional[str] = None
+) -> List[SanctionRecord]:
+    """Internal function to query sanction APIs"""
+    try:
+        headers = {}
+        if token:
+            headers["chave-api-dados"] = token
+        
+        params = {"cnpjCpf": cnpj_cpf}
+        
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(
+                f"{TRANSPARENCIA_URL}/{endpoint}",
+                params=params,
+                headers=headers
+            )
+            
+            if response.status_code == 401:
+                # Need authentication - return empty for now
+                print(f"Portal da Transparência requires authentication for {endpoint}")
+                return []
+            
+            if response.status_code != 200:
+                return []
+            
+            data = response.json()
+            if not isinstance(data, list):
+                data = [data] if data else []
+            
+            records = []
+            for item in data:
+                records.append(SanctionRecord(
+                    tipo=endpoint.upper(),
+                    cpf_cnpj=item.get("cpfCnpj", ""),
+                    nome=item.get("nomeRazaoSocial", item.get("nome", "")),
+                    tipo_pessoa=item.get("tipoPessoa", ""),
+                    tipo_sancao=item.get("tipoSancao", {}).get("descricao", "") if isinstance(item.get("tipoSancao"), dict) else str(item.get("tipoSancao", "")),
+                    data_inicio=item.get("dataInicioSancao", ""),
+                    data_fim=item.get("dataFimSancao", ""),
+                    orgao_sancionador=item.get("orgaoSancionador", {}).get("nome", "") if isinstance(item.get("orgaoSancionador"), dict) else str(item.get("orgaoSancionador", "")),
+                    uf_orgao=item.get("ufOrgaoSancionador", ""),
+                    fundamentacao_legal=item.get("fundamentacaoLegal", ""),
+                    fonte_url=f"https://portaldatransparencia.gov.br/{endpoint}"
+                ))
+            
+            return records
+            
+    except Exception as e:
+        print(f"Transparência API error ({endpoint}): {e}")
+        return []
+
+
+async def verificar_sancoes(cnpj_cpf: str, token: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Check all sanction databases for a CNPJ/CPF
+    Returns consolidated result
+    """
+    import asyncio
+    
+    # Query all databases in parallel
+    ceis_task = consultar_ceis(cnpj_cpf, token)
+    cnep_task = consultar_cnep(cnpj_cpf, token)
+    cepim_task = consultar_cepim(cnpj_cpf, token)
+    
+    ceis, cnep, cepim = await asyncio.gather(ceis_task, cnep_task, cepim_task)
+    
+    all_sanctions = ceis + cnep + cepim
+    
+    return {
+        "cnpj_cpf": cnpj_cpf,
+        "tem_sancoes": len(all_sanctions) > 0,
+        "total_sancoes": len(all_sanctions),
+        "ceis": len(ceis),
+        "cnep": len(cnep),
+        "cepim": len(cepim),
+        "registros": [
+            {
+                "tipo": s.tipo,
+                "tipo_sancao": s.tipo_sancao,
+                "orgao": s.orgao_sancionador,
+                "inicio": s.data_inicio,
+                "fim": s.data_fim,
+                "fundamentacao": s.fundamentacao_legal
+            }
+            for s in all_sanctions
+        ]
+    }