Qual método de recuperação é o melhor?

GraphRAG e Vector RAG atendem a diferentes necessidades de recuperação. Vector RAG divide documentos em pedaços, incorpora-os, recupera passagens semanticamente semelhantes e os envia para um LLM. É simples, rápido de construir e funciona melhor quando as respostas estão dentro de um ou dois blocos relevantes.

GraphRAG adiciona estrutura extraindo entidades, relacionamentos e comunidades, tornando-o mais forte para raciocínio multi-hop, explicabilidade e síntese de todo o corpus através de ideias conectadas. Neste artigo, uma comparação prática entre GraphRAG e Vector RAG, detalharemos onde cada abordagem se encaixa melhor.

Definições e Arquitetura

Vector RAG funciona dividindo documentos em pequenos pedaços de texto. Cada pedaço é convertido em uma incorporação e armazenado em um banco de dados vetorial. Quando um usuário faz uma pergunta, a pergunta também é convertida em incorporação. O sistema então encontra os pedaços mais semelhantes e os envia ao LLM para gerar uma resposta.

Vector RAG é simples, rápido e fácil de atualizar. Funciona bem para questões factuais diretas. Mas armazena significado principalmente através de incorporações e texto, e não através de entidades ou relacionamentos explícitos. Por causa disso, ele pode ter dificuldades com questões que precisam de conexões entre vários blocos.

GraphRAG adiciona mais estrutura. Extrai entidades, relacionamentos, reivindicações e comunidades dos documentos. Em seguida, ele constrói um gráfico que mostra como diferentes informações estão conectadas.

Isso torna o GraphRAG melhor para questões baseadas em relacionamento, raciocínio em várias etapas e amplo entendimento em um grande conjunto de documentos. A desvantagem é que é necessário mais esforço e custo para construir porque precisa de construção de gráficos, detecção de comunidade e resumo.

Na prática, muitos sistemas usam ambos. A pesquisa vetorial encontra rapidamente texto relevante, enquanto a recuperação de gráficos adiciona contexto conectado e melhor raciocínio.

Como funciona a recuperação no momento da consulta

A maior diferença entre Vector RAG e GraphRAG fica clara no momento da consulta. No Vector RAG, a consulta é tratada como um problema de pesquisa semântica. A pergunta do usuário é convertida em uma incorporação. O sistema compara esta incorporação de consulta com incorporações de blocos armazenados. Ele recupera os pedaços mais próximos e os envia para o LLM. O LLM então responde usando apenas esses pedaços como contexto. Isto funciona bem quando a resposta está diretamente disponível num pequeno conjunto de passagens semelhantes.

GraphRAG trata a consulta de maneira diferente. Primeiro tenta entender se a questão é native ou international. Uma questão native é sobre uma entidade, evento, cliente, produto ou documento específico. Uma questão international pede temas, padrões, riscos, resumos ou relações em todo o corpus.

Isso significa que o Vector RAG recupera por similaridade, enquanto o GraphRAG recupera por estrutura e significado juntos. Vector RAG é mais rápido e fácil quando a questão é restrita. GraphRAG é mais forte quando a resposta depende de conexões entre muitos documentos. Um sistema híbrido pode usar ambos os caminhos. Ele pode primeiro recuperar pedaços relevantes por meio de pesquisa vetorial e, em seguida, expandir o contexto usando relacionamentos gráficos. Isso dá ao LLM evidência textual e base estruturada.

Prática: Crie Vector RAG e GraphRAG do início ao fim

Nesta seção prática, construiremos Vector RAG e GraphRAG no mesmo pequeno corpus. O objetivo é simples. Queremos mostrar como o Vector RAG recupera pedaços de texto semelhantes, enquanto o GraphRAG recupera entidades, relacionamentos e contexto conectado. Usaremos Python, SentenceTransformers para embeddings, FAISS para pesquisa vetorial e NetworkX para armazenamento e travessia de gráficos. SentençaTransformers suporta codificação de texto em embeddings, FAISS é construído para pesquisa eficiente de similaridade vetorial e NetworkX armazena gráficos como nós e arestas com atributos.

Primeiro, instale as bibliotecas necessárias.

pip set up sentence-transformers faiss-cpu networkx pandas numpy

Agora crie um pequeno corpus de demonstração. Este corpus é intencionalmente pequeno, então a diferença é fácil de mostrar.

docs = (
    {
        "id": "doc1",
        "textual content": "NourishCo is going through rising logistics prices in its North area. The operations workforce believes the problem is linked to poor demand forecasting.",
    },
    {
        "id": "doc2",
        "textual content": "The North area makes use of Vendor A for chilly chain supply. Vendor A has repeated supply delays throughout high-demand weeks.",
    },
    {
        "id": "doc3",
        "textual content": "The analytics workforce proposed a machine studying forecasting mannequin to cut back stockouts and enhance provide planning.",
    },
    {
        "id": "doc4",
        "textual content": "The finance workforce is worried that Vendor A delays are growing working capital strain as a result of stock buffers are rising.",
    },
    {
        "id": "doc5",
        "textual content": "The management workforce needs an AI roadmap that connects demand forecasting, logistics optimization, and vendor efficiency monitoring.",
    },
)

Agora defina uma função de chunking simples. Nesta demonstração, cada documento já é curto, então trataremos cada documento como um pedaço.

chunks = ()

for doc in docs:
    chunks.append({
        "chunk_id": doc("id"),
        "textual content": doc("textual content"),
    })

print(chunks)

Agora construa o índice Vector RAG.

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

mannequin = SentenceTransformer("all-MiniLM-L6-v2")

texts = (chunk("textual content") for chunk in chunks)
embeddings = mannequin.encode(texts, convert_to_numpy=True)

dimension = embeddings.form(1)
index = faiss.IndexFlatL2(dimension)
index.add(embeddings)

print("Vector index created with", index.ntotal, "chunks")

Agora crie uma função de recuperação Vector RAG.

def vector_rag_search(question, top_k=3):
    query_embedding = mannequin.encode((question), convert_to_numpy=True)

    distances, indices = index.search(query_embedding, top_k)

    outcomes = ()

    for idx in indices(0):
        outcomes.append(chunks(idx))

    return outcomes


# Take a look at the Vector RAG pipeline
question = "Why are logistics prices rising within the North area?"

vector_results = vector_rag_search(question)

for end in vector_results:
    print(outcome("chunk_id"), ":", outcome("textual content"))

Isso recupera pedaços que estão semanticamente próximos da pergunta. Deverá devolver documentos sobre região Norte, custos logísticos, Fornecedor A e atrasos. Isso é útil quando a resposta está presente em um ou dois blocos semelhantes.

Agora vamos construir o GráficoRAG versão. Num sistema de produção, entidades e relacionamentos são geralmente extraídos com um LLM ou um modelo de extração de informações. Para esta demonstração prática, iremos defini-los manualmente para que o fluxo seja fácil de entender e explicar.

import networkx as nx

G = nx.Graph()

entities = (
    "NourishCo",
    "North Area",
    "Logistics Prices",
    "Demand Forecasting",
    "Vendor A",
    "Supply Delays",
    "Analytics Crew",
    "ML Forecasting Mannequin",
    "Stockouts",
    "Provide Planning",
    "Finance Crew",
    "Working Capital Strain",
    "Stock Buffers",
    "Management Crew",
    "AI Roadmap",
    "Logistics Optimization",
    "Vendor Efficiency Monitoring",
)

G.add_nodes_from(entities)

relationships = (
    ("NourishCo", "North Area", "operates in"),
    ("North Area", "Logistics Prices", "has challenge"),
    ("Logistics Prices", "Demand Forecasting", "linked to"),
    ("North Area", "Vendor A", "makes use of"),
    ("Vendor A", "Supply Delays", "causes"),
    ("Supply Delays", "Logistics Prices", "will increase"),
    ("Analytics Crew", "ML Forecasting Mannequin", "proposed"),
    ("ML Forecasting Mannequin", "Demand Forecasting", "improves"),
    ("ML Forecasting Mannequin", "Stockouts", "reduces"),
    ("ML Forecasting Mannequin", "Provide Planning", "improves"),
    ("Finance Crew", "Working Capital Strain", "involved about"),
    ("Vendor A", "Working Capital Strain", "contributes to"),
    ("Stock Buffers", "Working Capital Strain", "improve"),
    ("Supply Delays", "Stock Buffers", "improve"),
    ("Management Crew", "AI Roadmap", "needs"),
    ("AI Roadmap", "Demand Forecasting", "contains"),
    ("AI Roadmap", "Logistics Optimization", "contains"),
    ("AI Roadmap", "Vendor Efficiency Monitoring", "contains"),
)

for supply, goal, relation in relationships:
    G.add_edge(supply, goal, relation=relation)

print(
    "Graph created with",
    G.number_of_nodes(),
    "nodes and",
    G.number_of_edges(),
    "edges",
)

Agora crie uma função para inspecionar os vizinhos do gráfico.

def get_graph_context(entity, depth=1):
    if entity not in G:
        return ()

    context = ()
    visited = set((entity))
    frontier = (entity)

    for _ in vary(depth):
        next_frontier = ()

        for node in frontier:
            for neighbor in G.neighbors(node):
                edge_data = G.get_edge_data(node, neighbor)
                relation = edge_data("relation")

                context.append({
                    "supply": node,
                    "relation": relation,
                    "goal": neighbor,
                })

                if neighbor not in visited:
                    visited.add(neighbor)
                    next_frontier.append(neighbor)

        frontier = next_frontier

    return context


# Take a look at the graph retrieval
graph_results = get_graph_context("Vendor A", depth=2)

for merchandise in graph_results:
    print(merchandise("supply"), "--", merchandise("relation"), "--", merchandise("goal"))

Isso fornece um contexto conectado. Ele não recupera apenas pedaços semelhantes. Ele mostra como o Fornecedor A se relaciona com atrasos nas entregas, custos logísticos, reservas de estoque e pressão de capital de giro.

Agora criamos uma função de consulta GraphRAG simples. Para a demonstração, mapearemos palavras-chave de consulta para entidades.

def detect_entity(question):
    query_lower = question.decrease()

    entity_map = {
        "vendor": "Vendor A",
        "logistics": "Logistics Prices",
        "north": "North Area",
        "forecasting": "Demand Forecasting",
        "working capital": "Working Capital Strain",
        "monetary strain": "Working Capital Strain",
        "roadmap": "AI Roadmap",
    }

    for key phrase, entity in entity_map.gadgets():
        if key phrase in query_lower:
            return entity

    return None


def graph_rag_search(question, depth=2):
    entity = detect_entity(question)

    if not entity:
        return ()

    return get_graph_context(entity, depth=depth)


# Take a look at GraphRAG
question = "How is Vendor A related to monetary strain?"

graph_context = graph_rag_search(question)

for merchandise in graph_context:
    print(merchandise("supply"), "--", merchandise("relation"), "--", merchandise("goal"))

Agora evaluate os dois métodos na mesma consulta.

question = "How is Vendor A related to monetary strain?"

print("VECTOR RAG RESULTS")

vector_results = vector_rag_search(question)

for end in vector_results:
    print("-", outcome("textual content"))

print("nGRAPHRAG RESULTS")

graph_context = graph_rag_search(question)

for merchandise in graph_context:
    print("-", merchandise("supply"), merchandise("relation"), merchandise("goal"))

A saída Vector RAG retornará os pedaços de texto mais semelhantes. Pode encontrar o documento financeiro e o documento do Fornecedor A. GraphRAG mostrará a cadeia de relacionamento com mais clareza. Pode mostrar que o fornecedor A causa atrasos na entrega, os atrasos na entrega aumentam os buffers de estoque e os buffers de estoque aumentam a pressão do capital de giro.

Agora adicione um gerador de respostas simples. Esta versão não requer uma API LLM. Ele cria uma resposta legível a partir do contexto recuperado.

def generate_vector_answer(question, retrieved_chunks):
    context = " ".be part of((chunk("textual content") for chunk in retrieved_chunks))

    reply = f"""
Query: {question}

Vector RAG Reply:

Primarily based on the retrieved chunks, {context}
"""

    return reply


def generate_graph_answer(question, graph_context):
    info = ()

    for merchandise in graph_context:
        info.append(
            f"{merchandise('supply')} {merchandise('relation')} {merchandise('goal')}"
        )

    joined_facts = ". ".be part of(info)

    reply = f"""
Query: {question}

GraphRAG Reply:

Primarily based on the graph relationships, {joined_facts}.
"""

    return reply


# Run each reply turbines
question = "How is Vendor A related to monetary strain?"

vector_context = vector_rag_search(question)
graph_context = graph_rag_search(question)

print(generate_vector_answer(question, vector_context))
print(generate_graph_answer(question, graph_context))

Para uma demonstração mais realista, você pode conectar esta saída de recuperação a um LLM. O immediate do LLM pode ser mantido simples.

def build_llm_prompt(question, vector_context, graph_context):
    vector_text = "n".be part of((chunk("textual content") for chunk in vector_context))

    graph_text = "n".be part of((
        f"{merchandise('supply')} -- {merchandise('relation')} -- {merchandise('goal')}"
        for merchandise in graph_context
    ))

    immediate = f"""
You're a enterprise analyst.

Reply the query utilizing solely the offered context.

Query:
{question}

Vector Context:
{vector_text}

Graph Context:
{graph_text}

Last Reply:
"""

    return immediate


immediate = build_llm_prompt(question, vector_context, graph_context)

print(immediate)

Quando usar Vector RAG, GraphRAG ou Hybrid RAG

Usar Vetor RAG quando a resposta provavelmente está presente em um ou alguns trechos de texto. É simples, rápido e funciona bem para perguntas de pesquisa direta.

Os casos de uso comuns incluem:

• Perguntas frequentes
• Documentos de política
• Manuais do produto
• Artigos de suporte
• Pesquisa de documentos
• Assistentes de conhecimento básico

Uma pergunta típica do Vector RAG é assim:

“O que diz a política de reembolso?”

Usar GráficoRAG quando a resposta depende dos relacionamentos em todo o corpus. É melhor para conectar entidades, eventos, riscos, equipes, fornecedores e processos de negócios.

Os casos de uso comuns incluem:

• Análise de causa raiz
• Revisão de conformidade
• Investigações
• Análise de risco
• Análise de fornecedor
• Síntese estratégica
• Descoberta de conhecimento

Uma pergunta típica do GraphRAG é semelhante a:

“Como o Fornecedor A está conectado à pressão financeira na região Norte?”

Usar RAG Híbrido quando o sistema precisa de recuperação rápida e raciocínio mais profundo. A pesquisa vetorial pode encontrar rapidamente texto relevante, enquanto a recuperação gráfica adiciona contexto conectado.

Geralmente, essa é a melhor configuração de produção porque usuários reais fazem perguntas confusas. Algumas perguntas são pesquisas simples. Outros precisam de raciocínio multi-hop. Alguns precisam de ambos.

Uma regra de roteamento simples:

Direct factual query → Vector RAG
Relationship-heavy query → GraphRAG
Combined or strategic query → Hybrid RAG

A regra prática é simples: comece com Vector RAG. Adicione GraphRAG quando a pesquisa por similaridade perder conexões importantes. Use o Hybrid RAG quando o aplicativo precisar de velocidade e estrutura.

Compensações de desempenho, custo e manutenção

Limitações e modos de falha

Está tudo bem até que as coisas parem. Veja como isso pode acontecer:

• Onde o Vector RAG pode falhar
  • O Vector RAG pode ter dificuldades quando a resposta certa não está contida em um pedaço claro.
  • Pode recuperar texto que parece semanticamente semelhante, mas não responde totalmente à pergunta.
  • Isso é comum quando a consulta exige raciocínio em vários documentos.
  • Como o Vector RAG não entende explicitamente entidades, caminhos ou dependências, ele pode perder relacionamentos ocultos entre conceitos.
• Onde o GraphRAG pode falhar
  • GraphRAG pode falhar quando o gráfico subjacente está fraco ou incompleto.
  • Se a extração da entidade for imprecisa, esses erros serão transportados para o gráfico.
  • Se faltarem relações importantes, o sistema pode produzir uma resposta incompleta ou enganosa.
  • GraphRAG também requer mais pré-processamento do que Vector RAG.
  • Para tarefas de pesquisa simples, o custo e a complexidade adicionais nem sempre valem a pena.
• O desafio do frescor
  • O Vector RAG geralmente é mais fácil de atualizar quando os documentos de origem são alterados.
  • GraphRAG pode exigir atualizações de gráficos, resumos atualizados e validação de relacionamento.
  • Isso torna a manutenção mais complexa ao longo do tempo.
• Escolhendo a abordagem certa
  • Avalie ambos os sistemas em questões reais de usuários.
  • Comece com Vector RAG como linha de base.
  • Adicione GraphRAG somente quando a linha de base falhar em questões de relacionamento intenso ou de todo o corpus.
  • Use RAG híbrido quando o mesmo aplicativo precisar de pesquisa direta e raciocínio mais profundo.

Conclusão

Vector RAG e GraphRAG são úteis, mas resolvem problemas diferentes. Vector RAG é o melhor primeiro passo. É rápido, simples e forte para perguntas diretas. GraphRAG é útil quando as respostas dependem de entidades, relacionamentos, caminhos e temas em muitos documentos. Acrescenta estrutura, mas também acrescenta custos e esforço de manutenção. Em projetos reais, a melhor abordagem costuma ser híbrida. Use Vector RAG para evidências rápidas. Use GraphRAG para raciocínio conectado. O objetivo não é construir o sistema mais complexo. O objetivo é recuperar o contexto certo e gerar respostas confiáveis.

Perguntas frequentes

Olá, sou Janvi, um entusiasta apaixonado pela ciência de dados que atualmente trabalha na Analytics Vidhya. Minha jornada no mundo dos dados começou com uma profunda curiosidade sobre como podemos extrair insights significativos de conjuntos de dados complexos.