14-01-01 — Patterns: RAG, Agentic Workflow, Prompt Chaining, Routing, Parallelization

1. RAG — Retrieval-Augmented Generation

O pattern mais usado em enterprise. Em vez de depender do conhecimento do modelo (que pode estar desatualizado ou ser impreciso), o sistema busca informações relevantes antes de gerar a resposta.

Componentes:

• Indexing pipeline: Documentos → chunking → embeddings → vector store
• Retrieval: Query embedding → similarity search → top-K chunks
• Generation: [System prompt] + [chunks] + [query] → LLM → resposta

Variantes:

• Naive RAG: Busca simples por similaridade cosine
• Advanced RAG: Re-ranking, query expansion, hypothetical document embeddings (HyDE)
• Modular RAG: Componentes plugáveis, routing por tipo de query
• GraphRAG: Knowledge graph + embeddings para relações entre entidades

# RAG básico com Azure AI Search + Azure OpenAI
from azure.search.documents import SearchClient
from openai import AzureOpenAI

search_client = SearchClient(endpoint, index_name, credential)
openai_client = AzureOpenAI(azure_endpoint=endpoint, api_version="2024-05-01-preview")

def rag_query(user_query: str) -> str:
    # 1. Retrieve
    results = search_client.search(
        search_text=user_query,
        query_type="semantic",
        semantic_configuration_name="my-semantic-config",
        top=5,
        select=["content", "source", "title"]
    )
    
    chunks = [doc["content"] for doc in results]
    context = "\n\n---\n\n".join(chunks)
    
    # 2. Generate
    response = openai_client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": f"Use apenas o contexto abaixo para responder.\n\nContexto:\n{context}"},
            {"role": "user", "content": user_query}
        ]
    )
    return response.choices[0].message.content

2. Prompt Chaining

Decompõe tarefas complexas em uma sequência de prompts menores. A saída de cada etapa alimenta a próxima. Reduz alucinação em tarefas que exigem raciocínio multi-etapas.

Exemplo — Análise de contrato:

1. Prompt 1: "Extraia as partes, objeto e valor do contrato" → JSON estruturado
2. Prompt 2: "Dado o JSON abaixo, identifique cláusulas de risco" → lista de riscos
3. Prompt 3: "Dado os riscos abaixo, rascunhe um resumo executivo de 3 parágrafos" → texto final

3. Routing

Uma query chega ao sistema e um classificador decide qual handler deve processá-la. Reduz custo (queries simples vão para modelos menores) e melhora qualidade (queries especializadas vão para modelos específicos).

async def intelligent_router(query: str) -> str:
    # Classifica a intent com modelo pequeno
    intent = await classify_intent(query, model="gpt-4o-mini")
    
    match intent:
        case "factual_lookup":
            return await rag_search(query)
        case "code_generation":
            return await code_model(query)  # ex: modelo especializado em código
        case "document_analysis":
            return await document_pipeline(query)
        case "casual_conversation":
            return await light_model(query, model="gpt-4o-mini")
        case _:
            return await full_model(query, model="gpt-4o")

4. Parallelization

Executa múltiplas chamadas ao LLM simultaneamente quando as tarefas são independentes entre si. Reduz latência total em pipelines complexos.

Sectioning: Divide documento grande em seções → processa cada seção em paralelo → combina resultados.

Voting: Executa o mesmo prompt N vezes com temperatura alta → agrega respostas para maior robustez.

import asyncio

async def analyze_document_sections(sections: list[str]) -> list[str]:
    tasks = [analyze_section(section) for section in sections]
    results = await asyncio.gather(*tasks)
    return results

# Todas as seções são analisadas em paralelo
# Latência total ≈ latência de 1 seção, não N seções

5. Agentic Workflow

O LLM decide quais ações tomar, em que ordem, baseado no objetivo e no estado atual. O agente tem acesso a ferramentas (tools) e pode iterar até completar a tarefa.

Combinando Patterns

Sistemas reais combinam múltiplos patterns. Um assistente corporativo típico:

• Routing para classificar tipo de query
• RAG para queries sobre documentos internos
• Agentic para tarefas que requerem múltiplas ferramentas
• Chaining para workflows de longa duração
• Parallelization para análise de documentos extensos