🔧 Exemplos Práticos — Código para aplicar o que estudaste

Este tópico reúne código exemplo dos conceitos que estudaste: RAG, Fine-tuning e LangGraph. Podes executar alguns aqui; outros requerem pip install para correr localmente.

---

1. RAG — Pipeline mínimo

Exemplo que podes executar aqui (usa simulação de embeddings com similaridade por palavras):

# RAG mínimo — chunking + retrieval + geração (simulado)
def chunk_text(text, chunk_size=100, overlap=20):
    """Chunking por tamanho fixo com overlap."""
    words = text.split()
    chunks = []
    for i in range(0, len(words), chunk_size - overlap):
        chunk = " ".join(words[i:i + chunk_size])
        if chunk:
            chunks.append(chunk)
    return chunks

def simple_retrieve(query, chunks, top_k=2):
    """Retrieval por overlap de palavras (simula semantic search)."""
    q_words = set(query.lower().split())
    scored = []
    for i, c in enumerate(chunks):
        c_words = set(c.lower().split())
        overlap = len(q_words & c_words) / max(len(q_words), 1)
        scored.append((overlap, i, c))
    scored.sort(reverse=True, key=lambda x: x[0])
    return [s[2] for s in scored[:top_k]]

docs = """RAG combina LLMs com retrieval. A query vai a embedding, depois vector search.
Documentos relevantes são injetados no prompt. O LLM gera resposta fundamentada.
Reduz hallucinations e mantém conhecimento atualizado."""

chunks = chunk_text(docs)
query = "Como funciona RAG?"
context = simple_retrieve(query, chunks)
print("Contexto recuperado:")
for c in context:
    print(" -", c[:80] + "...")
print("\nPrompt para LLM: Contexto + Query")

Em produção: usarias sentence-transformers para embeddings e chromadb/pinecone para vector DB.

---

2. Fine-tuning — Estrutura com Hugging Face

Estrutura típica para fine-tuning (requer pip install transformers datasets peft):

# Estrutura de fine-tuning com LoRA
# pip install transformers datasets peft accelerate

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model
from datasets import load_dataset

# 1. Carregar modelo e tokenizer
model_name = "meta-llama/Llama-2-7b-hf"  # ou mistral, etc.
model = AutoModelForCausalLM.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 2. Configurar LoRA (Low-Rank Adaptation)
lora_config = LoraConfig(
    r=8,                    # rank
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
)
model = get_peft_model(model, lora_config)

# 3. Preparar dados (formato: {"text": "instrução\nresposta"})
dataset = load_dataset("json", data_files="train.json")

def format_instruction(example):
    return {"text": f"### Instrução\n{example['instruction']}\n### Resposta\n{example['output']}"}

dataset = dataset.map(format_instruction, remove_columns=dataset["train"].column_names)

tokenized = dataset.map(
    lambda x: tokenizer(x["text"], truncation=True, max_length=512),
    batched=True
)

# 4. Training arguments
training_args = TrainingArguments(
    output_dir="./output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-5,
    fp16=True,
)

# 5. Trainer e treino
from transformers import Trainer
trainer = Trainer(model=model, args=training_args, train_dataset=tokenized["train"])
# trainer.train()
# trainer.save_model()

Quando usar: alterar comportamento/estilo do modelo. Para conhecimento externo → RAG.

---

3. LangGraph — Conversação com estado

Exemplo de grafo com conversação e memória (requer pip install langgraph langchain-openai):

# LangGraph — conversação com state
# pip install langgraph langchain langchain-openai

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages

# State: mensagens acumuladas
class State(TypedDict):
    messages: Annotated[list, add_messages]

def chatbot_node(state: State):
    """Nó que processa a mensagem do user e gera resposta."""
    from langchain_openai import ChatOpenAI
    from langchain_core.messages import HumanMessage, AIMessage
    
    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: State):
    """Condição: continuar ou terminar."""
    last = state["messages"][-1]
    if hasattr(last, "content") and "bye" in str(last.content).lower():
        return "end"
    return "continue"

# Construir grafo
graph = StateGraph(State)
graph.add_node("chatbot", chatbot_node)
graph.add_conditional_edges("chatbot", should_continue, {"continue": "chatbot", "end": END})
graph.set_entry_point("chatbot")

app = graph.compile()

# Uso:
# from langchain_core.messages import HumanMessage
# result = app.invoke({"messages": [HumanMessage(content="Olá!")]})
# print(result["messages"][-1].content)

Fluxo: User → chatbot_node → (resposta) → condição → volta ao chatbot ou END.

---

4. RAG com LangChain (referência)

# RAG com LangChain — estrutura completa
# pip install langchain langchain-openai chromadb

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA

# 1. Carregar e chunkar
docs = TextLoader("doc.txt").load()
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
splits = splitter.split_documents(docs)

# 2. Embeddings + Vector Store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(splits, embeddings)

# 3. Retrieval QA chain
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
qa = RetrievalQA.from_chain_type(llm, retriever=vectorstore.as_retriever(k=3))

# 4. Query
result = qa.invoke("O que é RAG?")
print(result["result"])

---

Resumo — O que cada exemplo mostra

Próximo passo: copia o código, instala as dependências e corre localmente. Experimenta alterar chunk_size, top_k, ou adicionar nós ao grafo.