Databricks Certified Generative AI Engineer Associate

Prompt com formato garantido

Você é um assistente de suporte. Responda SOMENTE em JSON válido, sem texto fora do JSON:
{"categoria": "cobrança|entrega|produto", "urgencia": 1-5, "resumo": "<até 20 palavras>"}

Exemplo:
Entrada: "Fui cobrado duas vezes!"
Saída: {"categoria": "cobrança", "urgencia": 4, "resumo": "Cobrança duplicada"}

Instrução clara + schema + exemplo (few-shot). Melhor ainda: structured outputs (response_format com JSON schema) quando o endpoint suporta.

Tarefa certa

Resumir → summarization; separar em categorias → classification; extrair campos → information extraction / NER; responder com base em documentos → RAG; traduzir → translation.

Chains e agentes

Entrada → (reescrita da pergunta) → retriever → prompt com contexto → LLM → (pós-processamento/validação) → saída. Em agentes, o LLM escolhe ferramentas em sequência: ordene para primeiro buscar informação, depois agir.

Agent Bricks

Chunking

Chunk maior ou menos overlap → menos chunks (menos embeddings). Chunk deve caber no contexto do modelo de embedding.

Extração por formato

PDF → pypdf, pdfplumber, unstructured; imagem escaneada → OCR (pytesseract); HTML → beautifulsoup; DOCX → python-docx. Ou ai_parse_document direto em SQL.

Do arquivo à tabela

docs = spark.read.format("binaryFile").load("/Volumes/main/rag/pdfs/")
chunks = docs.withColumn("texto", extrai_udf("content")).withColumn("chunk", F.explode(chunk_udf("texto")))
(chunks.select(F.monotonically_increasing_id().alias("id"), "path", "chunk")
   .write.option("delta.enableChangeDataFeed", "true").saveAsTable("main.rag.chunks"))

CDF ligado é exigido pelo índice Delta Sync do Vector Search.

Fontes e limpeza

Inclua os documentos que contêm a resposta (políticas, manuais, FAQs); dados estruturados por transação (datas de entrega, saldo) se buscam melhor por lookup/feature table ou ferramenta, não vetor. Remova cabeçalhos/rodapés repetidos, menus, boilerplate e duplicatas.

Avaliar e re-rankear

Métricas de recuperação: recall@k, precision@k, MRR, NDCG, além de juízes de retrieval relevance/groundedness do MLflow. Re-ranker (cross-encoder) reordena os top-N candidatos da busca vetorial por relevância real — melhora a precisão, mas adiciona latência.

Frameworks

LangChain/LangGraph, LlamaIndex, OpenAI Agents SDK, DSPy — todos funcionam na Databricks; o Mosaic AI Agent Framework + MLflow dão logging, avaliação, tracing e deploy uniformes, qualquer que seja o framework.

Escolhendo o LLM

Considere: qualidade na tarefa (benchmarks e sua avaliação), tamanho do contexto, latência e custo, licença, se precisa de tool calling/JSON. Model card traz tarefa, idiomas, dados de treino, licença e limitações.

Embedding: contexto e dimensão

Escolha um modelo cujo contexto ≥ tamanho do chunk. Se custo/latência importam mais que qualidade, pegue o menor modelo que cobre o chunk (ex.: chunks de 512 tokens → modelo de 512 de contexto e dimensão menor). Dimensão maior = índice maior e mais lento.

Guardrails

Na entrada: detectar prompt injection, tópicos proibidos, PII. Na saída: filtro de toxicidade, checagem de groundedness, validação de schema. Na Databricks: AI Gateway guardrails no endpoint, ou um LLM/classificador como verificador na chain.

Agentes com MLflow

import mlflow
from mlflow.pyfunc import ResponsesAgent

class MeuAgente(ResponsesAgent):
    def predict(self, request):
        ...  # chama LLM + ferramentas

mlflow.langchain.autolog()          # ou mlflow.openai.autolog(): tracing automático
mlflow.models.set_model(MeuAgente())

Logue com mlflow.pyfunc.log_model(python_model="agente.py", resources=[...]), registre no UC e faça deploy com databricks.agents.deploy().

Avaliação x monitoramento

Avaliação = antes do deploy, com dataset (às vezes com ground truth) e juízes. Monitoramento = em produção, sobre tráfego real (sem ground truth), com os mesmos scorers aplicados a uma amostra dos traces.

Dados estruturados em multiagente

Um Genie space vira ferramenta/subagente: o supervisor pergunta em linguagem natural e o Genie responde com SQL sobre as tabelas — ou chame a Genie Conversation API.

Vector Search

• Endpoint (compute) hospeda índices.
• Delta Sync index: sincroniza de uma tabela Delta (com CDF); embeddings calculados pela Databricks (managed) ou por você (self-managed). Sync triggered (você chama sync) ou continuous (segundos, mais caro).
• Direct Access index: você faz upsert/delete pela API.
• Tipos de endpoint: standard (baixa latência, alto QPS) e storage-optimized (bilhões de vetores, mais barato, latência maior).
• Hybrid search (vetor + palavra-chave) e reranking melhoram a relevância mas adicionam latência.

from databricks.vector_search.client import VectorSearchClient
vsc = VectorSearchClient()
idx = vsc.create_delta_sync_index(endpoint_name="vs_ep", index_name="main.rag.chunks_idx",
        source_table_name="main.rag.chunks", primary_key="id", pipeline_type="TRIGGERED",
        embedding_source_column="chunk", embedding_model_endpoint_name="databricks-gte-large-en")
idx.similarity_search(query_text="prazo de devolução", columns=["chunk", "path"], num_results=5)

Elementos de um RAG logado

Flavor (pyfunc/langchain), modelo de embedding, retriever, LLM, dependências (pip), input_example, signature e resources (endpoints e índices usados → credenciais automáticas no serving).

Acesso a recursos

Declare resources no log do modelo (endpoint de LLM, índice, Genie, função do UC) — o serving cria credenciais de curta duração (passthrough automático). Para segredos externos, use Databricks Secrets em variáveis de ambiente do endpoint.

Batch com ai_query

SELECT id, ai_query('databricks-meta-llama-3-3-70b-instruct',CONCAT('Classifique: ', texto)) FROM main.raw.reviews;

Milhões de linhas → ai_query (paralelo, sem servidor próprio); tempo real → endpoint.

Memória e estado

Conversas e memória de longo prazo em Lakebase (Postgres gerenciado) ou tabelas Delta — não em variáveis do processo.

MCP

• Gerenciado: servidores da Databricks (Vector Search, Genie, funções do UC, alguns serviços externos) — só referencie.
• Externo: servidor de terceiros via conexão do UC, credenciais em Secrets.
• Customizado: seu servidor hospedado como Databricks App.

Prompts e CI/CD

MLflow Prompt Registry: mlflow.genai.register_prompt(...) cria versões; aliases (@production) promovem e permitem rollback. Atualize índices no pipeline (sync após a ingestão) e teste ferramentas isoladamente.

Interface

Databricks Apps (Streamlit, Gradio, Dash, Node) com autenticação corporativa; o backend chama o endpoint com credenciais do app/usuário — nunca exponha tokens no navegador. Slack/Teams via bots que chamam o endpoint.

• Mascaramento de PII antes de enviar ao LLM (ai_mask, regex, máscaras do UC) protege dados e reduz risco sem perder utilidade.
• Entradas maliciosas (prompt injection, jailbreak): classificador de entrada, instruções de sistema robustas, separar dados de instruções, limitar ferramentas e permissões do agente.
• Licenças: use dados e modelos cuja licença permite o uso comercial pretendido; documente a origem (UC + tags).
• Texto problemático na fonte (tóxico, desatualizado, enviesado): filtrar ou remover na preparação, em vez de confiar só em guardrail de saída.

mlflow.genai.evaluate

from mlflow.genai.scorers import Correctness, RelevanceToQuery, RetrievalGroundedness, Safety, scorer

@scorer
def resposta_curta(outputs) -> bool:
    return len(outputs.split()) < 120

mlflow.genai.evaluate(data=dataset, predict_fn=agente,
    scorers=[Correctness(), RelevanceToQuery(), RetrievalGroundedness(), Safety(), resposta_curta])

• Exigem ground truth (resposta esperada/fatos): Correctness, retrieval sufficiency.
• Não exigem: relevância, groundedness, safety, guidelines.

Tracing

Cada chamada vira um trace com spans (retriever, LLM, ferramentas), latência e tokens — essencial para depurar e alimenta a avaliação.

Produção

• Inference tables (via AI Gateway): requests e responses gravados numa tabela Delta.
• Usage tables: tokens e custo por endpoint/usuário.
• Rate limiting: por usuário/endpoint para controlar custo e abuso.
• Agent monitoring: roda scorers numa amostra do tráfego real.

Custos

Modelo menor quando a qualidade permite, cache, limitar tokens de saída, rate limits, provisioned throughput só quando o volume justifica, batch com ai_query.

Feedback de especialistas

Review App / labeling sessions do MLflow. Para notas consistentes: rubricas claras, calibração dos avaliadores; depois alinhe juízes LLM a esses rótulos.