Construir um sistema de RAG com Gemini 2.0 Flash

Linha de fundo

Se você está construindo um sistema de RAG em 2026, Gemini O Flash 2.0 é a escolha padrão mais forte. A janela de contexto 1M-token permite que você pule completamente em corpora de pequeno a médio. O custo é baixo. O modelo incorporado (texto-embutindo-004) é excelente. A armadilha principal para evitar: usar o errado task_type Quando se preparam incorporações, mata silenciosamente a precisão de recuperação.

Construí sistemas de RAG no GPT-4o, Claude 3.5, e Mistral. Quando troquei um documento Q&Um fluxo de trabalho para Gemini 2.0 Flash para RAGA latência caiu 40% e eu cortei o custo por consulta pela metade. Aqui está a configuração exata que fez funcionar. E o erro de configuração que queimou três dias antes de eu encontrá-lo.

Por quê? Gemini 2.0 Flash para RAG

A janela de contexto do 1M não é apenas um número de folha. Muda as decisões de arquitetura. Para a maioria dos casos de uso de RAG baseados em documentos - bases de conhecimento interno, documentação de produto, corpora legal abaixo de 700K tokens - você pode Passe todo o corpus diretamente para o contexto. em vez de construir um fluxo de trabalho de recuperação.

Dito isso, uma vez que você vai além de 700 mil fichas, ou se você precisa de recuperação de precisão de palavras-chave em conteúdo técnico, uma pilha de recuperação híbrida vetor completo + ainda supera o recheio de contexto bruto. Eis o que importa:

• 1M janela de contexto - elimina o excesso de pedaços para os corpos pequenos a médios
• Tradução: - Supera o texto-embaciando-003 em MTEB recupera benchmarks
• Custo - £0,0004 por consulta típica de RAG (5 pedaços × 1.000 fichas + 500 token response)
• Fluxo - Nativo Async, com sub-400ms de tempo até o primeiro toque
• Multimodal - pode processar PDFs, imagens, e áudio nativa no mesmo fluxo de trabalho

A pilha que eu uso na produção

Esta é a configuração padrão para um Gemini Sistema de radares em 2026.

• LLM: gemini-2.0-flash via langchain-google-genai
• Embutidos: models/text-embedding-004 (Google AI generativo)
• Loja de Vetor: Chroma (dev) / pgvector ou Qdrant (produção)
• Recuperação: MRM + BM25 híbrido (EnsembleRetriever)
• Orquestração: LangChain 0,3.x
• Monitoramento: LangSmith (não negociável para produção)

uv add langchain langchain-google-genai langchain-community chromadb tiktoken langsmith

Passo 1: Inicializar LLM e Embeddings

É aqui que a maioria das pessoas se queima. O task_type O parâmetro no modelo de incorporação não é opcional. É a diferença entre 60% e 85% de precisão de recuperação.

from langchain_google_genai import ChatGoogleGenerativeAI, GoogleGenerativeAIEmbeddings
llm = ChatGoogleGenerativeAI(
    model="gemini-2.0-flash",
    temperature=0.1,          # Keep low for Q&A
    max_output_tokens=2048,
)
# For embedding documents into the vector store:
doc_embeddings = GoogleGenerativeAIEmbeddings(
    model="models/text-embedding-004",
    task_type="retrieval_document",   # <-- critical
)
# For embedding queries at retrieval time:
query_embeddings = GoogleGenerativeAIEmbeddings(
    model="models/text-embedding-004",
    task_type="retrieval_query",      # <-- also critical
)

**Pitchfall comum:

Passei três dias depurando má recuperação num corpus de documentos legais antes de perceber que tinha iniciado incorporação com task_type="similarity"- Não. Mudando para "retrieval_document" para indexação e "retrieval_query" Para consultas, a precisão aumentou 18 pontos percentuais. A API não é um erro, só silenciosamente retorna piores incorporações. Verifique isso antes de depurar qualquer coisa no seu fluxo de trabalho.

Passo 2: Estratégia de Chunking

Chunking só é necessário quando seu corpus excede 700 mil fichas. Abaixo disso, passe documentos diretamente no contexto e pule a loja de vetores inteiramente. Quando você precisa de pedacinhos:

from langchain.text_splitter import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    add_start_index=True,  # Helps debug retrieval misses
)

Recomendações de tamanho de chunk por tipo de conteúdo:

Passo 3: Prepare a recuperação híbrida

A busca por vetores falha em consultas pesadas de palavras-chave. Nomes de produtos, números de versão, códigos de modelos. BM25 cuida bem disso. - Não.

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever
from langchain_community.vectorstores import Chroma
# Vector store
vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=doc_embeddings,
    persist_directory="./chroma_db",
)
# MMR retriever — diversity > raw similarity
vector_retriever = vectorstore.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 5, "fetch_k": 20, "lambda_mult": 0.7},
)
# BM25 for keyword precision
bm25_retriever = BM25Retriever.from_documents(docs)
bm25_retriever.k = 5
# Hybrid: 60% semantic, 40% keyword
hybrid_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.4, 0.6],
)

Não-Obvios Dica: 5 Chunks Beat 30 Chunks

Gemini O Flash 2.0 tem uma janela de contexto de 1M. A tentação é recuperar mais de 30 pedaços e deixar o modelo descobrir. Não. Testei isso sistematicamente: 5 pedaços bem classificados via RMM + BM25 superam 30 pedaços na precisão de resposta em ~12%, enquanto cortam latência em 60% e custam 80%. Mais contexto introduz ruído que o modelo tem que filtrar. Mantenha sua recuperação apertada.

Passo 4: Construir a corrente RAG

from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate
system_prompt = """You answer questions based only on the provided context.
Context: {context}
Rules:
- Only use the context above to answer
- If the context doesn't contain the answer, say "I don't have enough information"
- Cite the source document when possible
- Be concise: 2–4 sentences unless detail is specifically requested
"""
prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    ("human", "{input}"),
])
qa_chain = create_stuff_documents_chain(llm, prompt)
rag_chain = create_retrieval_chain(hybrid_retriever, qa_chain)

Passo 5: Streaming + Retry Logic

Na produção, você atingirá limites de taxa e tempo limite. Construa isso de day one:

import asyncio
from tenacity import retry, stop_after_attempt, wait_exponential
@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10),
    reraise=True,
)
async def stream_rag(query: str):
    full_answer = ""
    async for chunk in rag_chain.astream({"input": query}):
        if "answer" in chunk:
            token = chunk["answer"]
            full_answer += token
            print(token, end="", flush=True)
    return full_answer
asyncio.run(stream_rag("What are the key terms in section 4?"))

Guia de Seleção de Vetor

Desempenho Real do Mundo:

Baseado em uma base de conhecimento legal de 400 documentos que eu implantei no Q1 2026:

• Hora de começar. 180-380ms (streaming) mode)
• Latência de resposta completa: 1.2-2.8 para uma resposta de 200 palavras.
• Custo por consulta: ~$0,0004 em 5 pedaços × 1.000 fichas + 500 token saída
• Precisão de recuperação@5 com híbrido: 87%
• Nível limite de taxa necessário: Nível pago (1.000+ RPM) para qualquer carga de produção acima de 15 consultas/min

Um real. scenario que mostrava os limites do sistema: quando um usuário queriou duas seções de um contrato de 500 páginas com números de cláusula conflitantes, o modelo corretamente sinalizava o conflito - mas só quando eu tinha ambos os pedaços em contexto. Quando apenas uma parte foi recuperada, respondeu confiantemente com a cláusula errada. É por isso que a diversidade de recuperação (MMR) importa mais do que a pontuação de similaridade crua.

Quando Gemini 2.0 Flash RAG Falls Short

Não é a ferramenta certa para cada situação.

• streams de dados em tempo real - Se seus documentos atualizarem em tempo real (bilhetes, entradas de CRM, bancos de dados ao vivo), um duoduto de ingestão de streaming com Kafka + pgvector lida melhor com isso.
• Raciocínio multi-hop em mais de 10 documentos. — Gemini Mas você precisa de um retriever baseado em gráficos, não de uma loja de vetores planas.
• Pesada matemática/código de execução RAG - para RAG que precisa executar o código ou calcular resultados, par com uma camada de ferramenta de interpretador de código, não apenas a base LLM

Perguntas frequentes

Is Gemini 2.0 Flash é bom para RAG?

Sim. A janela de contexto de 1M é a maior vantagem. Para a maioria dos corpos de documentos abaixo de 700 mil fichas você pode pular completamente os pedaços. Para conjuntos de dados maiores, use recuperação híbrida com BM25 + busca por vetores. É a melhor relação custo-qualidade para RAG em 2026.

Qual banco de dados vetorial funciona melhor com Gemini Flash 2.0?

Chroma para desenvolvimento, pgvector para produção sob documentos 1M (mantém dados relacionais em um sistema). Qdrant para alta escala. Pinecone se quiser infraestrutura zero.

Que modelo de incorporação devo usar?

Google's text-embedding-004- Não. Preparar. task_type='retrieval_document' quando a indexação e task_type='retrieval_query' Quando estava perguntando. Errado. task_type É a causa mais comum de má precisão de recuperação.

Próximo Passo

Prepare o seu Gemini 2.0 Flash pipeline hoje

Pegue sua chave de API. Google AI Studio, corra os cinco passos acima, e desempenhe com LangSmith monitorando ativado a partir de day one- Não. Se você tiver problemas de qualidade de recuperação, verifique task_type Primeiro, é a solução 80% do tempo.

Precisa de um papel FastAPI completo? Navegar AIListPrime Para mais guias →