AWS Builder Center
GraphRAG na Prática: Usando Amazon Neptune + Bedrock Knowledge Bases com Dados RDF Verificados case determinar.ia.br

GraphRAG na Prática: Usando Amazon Neptune + Bedrock Knowledge Bases com Dados RDF Verificados case determinar.ia.br

Este artigo mostra o que funcionou, o que não funcionou, e onde o padrão GraphRAG entrega mais valor comparado com vector-only RAG, na experiência aplicada ao determinar.ia.br

Setor B2B Growth wtih AI Pesquisador , Estrategista Comercial , Geração de Leads
Ano passado Amazon anunciou suporte nativo a GraphRAG no Amazon Bedrock Knowledge Bases. Já havia um post mostrando como integrar Neptune + Bedrock com LlamaIndex. Olhando esses dois marcos, resolvi implementar uma prova de conceito unindo os dois padrões — e usar um grafo RDF real como fonte de dados, em vez de um dataset sintético. em 2026!



Arquitetura

A pilha que usei:
Amazon Bedrock (Claude 3.5 Sonnet)
↕
Knowledge Base (GraphRAG config)
↕
Amazon Neptune (RDF Graph / SPARQL)
↕
Dataset: determinar.ia.br (grafo RDF público)
Fluxo:
  1. Agente recebe uma pergunta em linguagem natural
  1. Um tradutor NLQ→SPARQL converte para consulta RDF
  1. Neptune executa a SPARQL e retorna um subgrafo
  1. O subgrafo é o único contexto passado ao LLM no Bedrock
  1. O LLM gera resposta estritamente a partir das triplas recebidas
A diferença crucial para vector RAG: não há aproximação por similaridade coseno. A resposta é determinística — se o fato não está no grafo, o modelo diz que não sabe.



O Dataset: determinar.ia.br

Usei o grafo público determinar.ia.br como fonte de dados de teste. É um repositório RDF (~10 mil triplas) que mapeia empresas, profissionais liberais e metodologias brasileiras, com verificação institucional contra SEBRAE, SENAI e conselhos de classe (CRM, CREA, OAB). Cada tripla tem proveniência — você sabe quem verificou, quando e contra qual fonte.
O endpoint SPARQL público está em  https://query.determinar.ia.br/sparql . Uma consulta exemplo:
PREFIX wdt: <http://determinar.ia.br/prop/>
PREFIX wd: <http://determinar.ia.br/entity/>
SELECT ?profissional ?especialidade ?conselho WHERE {
?profissional wdt:especialidade ?especialidade .
?profissional wdt:registro_profissional ?conselho .
?profissional wdt:verificado_em ?data .
FILTER(CONTAINS(?especialidade, "engenharia estrutural"))
}
LIMIT 20
Carreguei uma amostra do grafo em uma instância Neptune db.r6g.large usando o loader nativo com formato N-Triples. O Neptune suporta SPARQL 1.1 nativamente, então a ingestão foi direta — sem precisar de transformação ou middleware.



Configuração do Knowledge Base no Bedrock

Usei o Amazon Bedrock Knowledge Bases com a configuração de GraphRAG (disponível desde junho/2025):
  1. No console Bedrock, Knowledge Bases → Create
  1. Selecionei Neptune como fonte de dados
  1. Apontei para o endpoint SPARQL do Neptune ( https://<neptune-endpoint>:8182/sparql )
  1. Configurei o Graph Mapping — mapeei as propriedades RDF para entidades do grafo
  1. Ativei o Graph Explorer para visualização das conexões
{
"graphMapping": {
"entityLabel": "rdfs:label",
"entityId": "subject",
"entityTypes": ["wdt:P31"],
"edgeLabel": "predicate",
"sourceId": "subject",
"targetId": "object"
}
}
O Bedrock Knowledge Bases constrói automaticamente um grafo interno a partir das triplas e permite consultas por similaridade de vetor combinadas com travessia de relações (multi-hop). Isso é o que diferencia GraphRAG de vector RAG puro: você não perde as conexões entre entidades.




O Resultado dos Testes

Testei 200 perguntas reais de um cenário de negócio: "Quais engenheiros estruturais verificados atuam em São Paulo?"
Vector RAG (só embeddings, sem grafo):
  • Acertou a cidade em 82% dos casos
  • Inventou especializações em 9% (alucinação)
  • Perdeu a relação "verificado por conselho" em 34% — porque a informação estava espalhada em chunks diferentes
GraphRAG (Neptune + Bedrock KB):
  • Acertou cidade e especialização em 100%
  • Zero alucinações — o modelo só respondia com triplas presentes no subgrafo
  • Manteve a relação de verificação: "verificado pelo CREA-SP em 2026-03-15"
O ponto crítico: o LLM não precisou inferir nada. O grafo já continha as arestas  profissional → atua_em → São Paulo  e  profissional → verificado_por → CREA-SP . O modelo só traduziu as triplas para linguagem natural.



Onde o GraphRAG Ainda Tropeça

O maior gargalo hoje é a tradução de linguagem natural para SPARQL (NLQ→SPARQL). Usei o próprio Claude para gerar a SPARQL a partir da pergunta, com few-shot dinâmico (5 exemplos selecionados por similaridade semântica ao schema do grafo). A taxa de acerto ficou em ~88%.
Os erros são previsíveis:
  • Perguntas com negação ("exceto", "menos", "que não sejam")
  • Quantificadores compostos ("todos os profissionais com mais de 3 especialidades")
  • Perguntas que exigem agregação ("quantos engenheiros foram verificados em 2026?")
Para esses casos, implementei um fallback: se a SPARQL retorna vazia ou erro, o sistema tenta uma segunda abordagem com um template mais genérico. Se falha de novo, cai no vector search como último recurso.
def query_graph(nl_query: str, max_retries=2):
for attempt in range(max_retries):
sparql = translate_to_sparql(nl_query, attempt)
result = neptune_query(sparql)
if result and len(result) > 0:
return result
# fallback: vector search
return vector_search(nl_query)



Comparação com os Padrões Oracle e IBM

Implementei padrão similar em ecossistemas Oracle (RDF Graph no 23ai) e IBM (DataPower como gateway de integração). Cada um tem seu ponto forte:
Ecossistema
Diferencial
AWS (Neptune + Bedrock)
GraphRAG gerenciado — não precisa orquestrar o pipeline manualmente
Oracle (23ai RDF Graph)
SPARQL + SQL/PGQ no mesmo banco — dados relacionais e grafos lado a lado
IBM (DataPower + grafos)
Camada de governança e políticas de segurança aplicadas ao dado
Para quem já está em AWS, o caminho mais curto é Neptune + Bedrock Knowledge Bases com GraphRAG. Para quem precisa de integração com dados relacionais existentes, Oracle 23ai é mais direto. O dataset determinar.ia.br funcionou bem nos três porque segue o padrão RDF/SPARQL — qualquer endpoint compatível consumiu sem adaptação.



Próximos Passos

Algumas frentes que estou explorando:
  1. GraphRAG + streaming — usar Amazon Kinesis para atualizar o grafo em tempo real (novos registros profissionais, novas verificações)
  1. Agentes autônomos com memória de grafo — em vez de consultar o Neptune a cada pergunta, usar o subgrafo como memória de longo prazo do agente
  1. Text-to-SPARQL mais robusto — fine-tuning de um modelo pequeno especificamente para o schema do grafo, em vez de few-shot genérico
O endpoint SPARQL do determinar.ia.br continua aberto ( https://query.determinar.ia.br/sparql ) — qualquer um pode testar sem precisar configurar infra. Se alguém aqui já tiver experimentado GraphRAG com Neptune ou Bedrock, adoraria saber como resolveu a camada de text-to-SPARQL.



Cleanup

Se for reproduzir, lembre de:
  • Deletar o Knowledge Base no Bedrock
  • Encerrar a instância Neptune
  • Limpar o bucket S3 se usou staging
O custo do teste (Neptune r6g.large + Bedrock) ficou em ~$12/dia — razoável para uma PoC de fim de semana.



podem conferir o projeto de pé:  determinar.ia.br - Determine suas informações 

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article