RAG na Prática: Como Construir Aplicações com Retrieval Augmented Generation

# Criar ambiente virtual
python -m venv rag-env
source rag-env/bin/activate  # Linux/macOS

# Instalar dependências
pip install langchain langchain-community langchain-openai
pip install chromadb
pip install sentence-transformers
pip install pypdf
pip install tiktoken

# Para interface web
pip install streamlit

# Para LLMs locais via Ollama
pip install langchain-ollama

# Verificar
python -c "import langchain; import chromadb; print('Tudo instalado!')"

from langchain_community.document_loaders import (
    PyPDFLoader, TextLoader, WebBaseLoader, DirectoryLoader
)
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Carregar PDFs
pdf_loader = PyPDFLoader("documentos/manual_empresa.pdf")
pdf_docs = pdf_loader.load()
print(f"PDF: {len(pdf_docs)} páginas carregadas")

# Carregar ficheiros de texto
txt_loader = TextLoader("documentos/politicas.txt", encoding="utf-8")
txt_docs = txt_loader.load()

# Carregar páginas web
web_loader = WebBaseLoader([
    "https://vibecodingacademy.pt/sobre",
    "https://vibecodingacademy.pt/cursos",
])
web_docs = web_loader.load()

# Carregar diretório inteiro
dir_loader = DirectoryLoader(
    "documentos/", glob="**/*.txt",
    loader_cls=TextLoader,
    loader_kwargs={"encoding": "utf-8"}
)
dir_docs = dir_loader.load()

# Combinar tudo
todos_docs = pdf_docs + txt_docs + web_docs + dir_docs
print(f"Total: {len(todos_docs)} documentos")

# Dividir em fragmentos
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,        # Tamanho máximo
    chunk_overlap=200,     # Sobreposição para continuidade
    separators=["\n\n", "\n", ". ", " ", ""],
)

fragmentos = text_splitter.split_documents(todos_docs)
print(f"Divididos em {len(fragmentos)} fragmentos")

for i, frag in enumerate(fragmentos[:3]):
    print(f"\n--- Fragmento {i+1} ({len(frag.page_content)} chars) ---")
    print(frag.page_content[:150] + "...")

from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma

# Embeddings locais GRATUITOS (sem API externa)
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2",
    model_kwargs={'device': 'cpu'},  # ou 'cuda' com GPU
    encode_kwargs={'normalize_embeddings': True}
)

# Para melhor qualidade em português:
# model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"

# Criar vector store com ChromaDB
vectorstore = Chroma.from_documents(
    documents=fragmentos,
    embedding=embeddings,
    persist_directory="./chroma_db",
    collection_name="documentos_empresa"
)
print(f"Vector store criado com {vectorstore._collection.count()} fragmentos")

# Pesquisar por semelhança
query = "Quais cursos de Machine Learning estão disponíveis?"
resultados = vectorstore.similarity_search(query, k=4)

print(f"\nPergunta: {query}")
for i, doc in enumerate(resultados):
    print(f"\n--- Resultado {i+1} ---")
    print(doc.page_content[:200])

# Pesquisa com score
resultados_score = vectorstore.similarity_search_with_score(query, k=4)
for doc, score in resultados_score:
    print(f"Score: {score:.4f} | {doc.page_content[:100]}...")

from langchain_community.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# LLM local via Ollama (GRATUITO)
llm = Ollama(model="llama3.1", temperature=0.3)

# Prompt template em português
prompt_template = PromptTemplate(
    template="""Usa o seguinte contexto para responder à pergunta.
Se não encontrares a resposta no contexto, diz que não tens informação.
Não inventes. Responde em português de Portugal.

Contexto:
{context}

Pergunta: {question}

Resposta útil e detalhada:""",
    input_variables=["context", "question"]
)

# Retriever
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 5}
)

# Chain RAG
rag_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True,
    chain_type_kwargs={"prompt": prompt_template}
)

# Fazer perguntas
def perguntar(pergunta: str):
    resultado = rag_chain.invoke({"query": pergunta})
    print(f"Pergunta: {pergunta}")
    print(f"\nResposta:\n{resultado['result']}")
    print(f"\nFontes ({len(resultado['source_documents'])}):")
    for doc in resultado['source_documents']:
        fonte = doc.metadata.get('source', 'N/A')
        print(f"  - {fonte}")

perguntar("Quais cursos de IA estão disponíveis e qual o preço?")
print("\n" + "=" * 60 + "\n")
perguntar("Qual é a política de cancelamento?")

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever

# Retriever BM25 (keywords)
retriever_bm25 = BM25Retriever.from_documents(fragmentos, k=5)

# Retriever semântico
retriever_semantico = vectorstore.as_retriever(search_kwargs={"k": 5})

# Combinar com pesos
retriever_hibrido = EnsembleRetriever(
    retrievers=[retriever_semantico, retriever_bm25],
    weights=[0.6, 0.4]  # 60% semântico, 40% keywords
)

resultado = retriever_hibrido.invoke("Preço do curso de Machine Learning")
for doc in resultado:
    print(f"- {doc.page_content[:150]}...")

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import CrossEncoderReranker
from langchain_community.cross_encoders import HuggingFaceCrossEncoder

cross_encoder = HuggingFaceCrossEncoder(
    model_name="cross-encoder/ms-marco-MiniLM-L-6-v2"
)

compressor = CrossEncoderReranker(model=cross_encoder, top_n=3)

retriever_reranked = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=retriever_semantico  # recupera 10, re-rank para 3
)

"""
Chatbot RAG com Streamlit
Executa: streamlit run chatbot_rag.py
"""
import streamlit as st
from langchain_community.llms import Ollama
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferWindowMemory

st.set_page_config(page_title="Assistente RAG", page_icon="🤖")
st.title("Assistente Inteligente com RAG")

@st.cache_resource
def inicializar_rag():
    embeddings = HuggingFaceEmbeddings(
        model_name="sentence-transformers/all-MiniLM-L6-v2"
    )
    vectorstore = Chroma(
        persist_directory="./chroma_db",
        embedding_function=embeddings
    )
    llm = Ollama(model="llama3.1", temperature=0.3)
    return vectorstore, llm

vectorstore, llm = inicializar_rag()

if "memory" not in st.session_state:
    st.session_state.memory = ConversationBufferWindowMemory(
        memory_key="chat_history", return_messages=True,
        output_key="answer", k=5
    )
if "mensagens" not in st.session_state:
    st.session_state.mensagens = []

qa_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=vectorstore.as_retriever(search_kwargs={"k": 4}),
    memory=st.session_state.memory,
    return_source_documents=True
)

# Mostrar histórico
for msg in st.session_state.mensagens:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

# Input
if pergunta := st.chat_input("Faz uma pergunta..."):
    st.session_state.mensagens.append({"role": "user", "content": pergunta})
    with st.chat_message("user"):
        st.markdown(pergunta)

    with st.chat_message("assistant"):
        with st.spinner("A pesquisar..."):
            resultado = qa_chain.invoke({"question": pergunta})
        st.markdown(resultado["answer"])

        if resultado.get("source_documents"):
            with st.expander("Ver fontes"):
                for doc in resultado["source_documents"]:
                    st.caption(doc.metadata.get("source", "N/A"))
                    st.text(doc.page_content[:200] + "...")

        st.session_state.mensagens.append({
            "role": "assistant", "content": resultado["answer"]
        })

with st.sidebar:
    st.metric("Docs indexados", vectorstore._collection.count())
    if st.button("Limpar conversa"):
        st.session_state.mensagens = []
        st.session_state.memory.clear()
        st.rerun()