Entrevista de AI Engineer: Perguntas e Respostas

Entrevistas para AI Engineer costumam ter 4-5 etapas. Neste guia, você vai aprender exatamente o que esperar e como se preparar para cada uma delas.

Estrutura Típica de Entrevista

Perguntas Conceituais sobre LLMs

1. "Explique como funciona o ChatGPT/GPT-4"

Resposta ideal:

"O GPT-4 é um Large Language Model baseado na arquitetura Transformer. Ele foi pré-treinado em grandes volumes de texto da internet para prever a próxima palavra em uma sequência. Depois, passou por fine-tuning com RLHF (Reinforcement Learning from Human Feedback) para alinhar as respostas com preferências humanas. Na inferência, ele gera texto de forma autorregressiva, uma palavra por vez, usando mecanismos de atenção para considerar todo o contexto."

2. "Qual a diferença entre fine-tuning e RAG?"

Resposta ideal:

Fine-tuning:
- Retreina o modelo com dados específicos
- Custo alto (compute + dados)
- Conhecimento fica "embutido" no modelo
- Bom para: estilo, formato, tarefas específicas

RAG (Retrieval-Augmented Generation):
- Não altera o modelo
- Busca informação relevante em runtime
- Conhecimento fica em banco de dados externo
- Bom para: dados que mudam, citações, fatos específicos

Quando usar cada um:
- RAG: FAQ, documentação, dados que atualizam
- Fine-tuning: tom de voz, formato específico
- Ambos: chatbot com personalidade + dados atuais

3. "Como você lida com alucinações de LLMs?"

Resposta ideal:

Estratégias para reduzir alucinações:

1. RAG com fontes confiáveis
   - Buscar informação factual antes de responder
   - Citar fontes na resposta

2. Temperatura baixa
   - temperature=0 para respostas factuais
   - Menos "criatividade", mais precisão

3. Prompts específicos
   - "Se não souber, diga 'não sei'"
   - "Cite apenas informações do contexto fornecido"

4. Validação de output
   - Verificar claims contra base de conhecimento
   - Segundo LLM para fact-checking

5. Grounding
   - Fornecer contexto específico no prompt
   - Limitar escopo das respostas

4. "O que são embeddings e como funcionam?"

Resposta ideal:

"Embeddings são representações vetoriais de texto em um espaço de alta dimensão. Textos semanticamente similares ficam próximos nesse espaço. Usamos modelos como text-embedding-ada-002 da OpenAI para gerar esses vetores. Em RAG, convertemos documentos em embeddings, armazenamos em um vector database, e na query, convertemos a pergunta em embedding e buscamos os documentos mais similares usando distância coseno."

Perguntas de Coding

5. "Implemente um sistema de RAG simples"

# O entrevistador quer ver você estruturar o código

from openai import OpenAI
from typing import List

class SimpleRAG:
    def __init__(self):
        self.client = OpenAI()
        self.documents = []
        self.embeddings = []
    
    def add_document(self, text: str):
        """Adiciona documento ao knowledge base."""
        embedding = self._get_embedding(text)
        self.documents.append(text)
        self.embeddings.append(embedding)
    
    def _get_embedding(self, text: str) -> List[float]:
        """Gera embedding para um texto."""
        response = self.client.embeddings.create(
            model="text-embedding-ada-002",
            input=text
        )
        return response.data[0].embedding
    
    def _cosine_similarity(self, a: List[float], b: List[float]) -> float:
        """Calcula similaridade entre dois vetores."""
        dot_product = sum(x * y for x, y in zip(a, b))
        norm_a = sum(x ** 2 for x in a) ** 0.5
        norm_b = sum(x ** 2 for x in b) ** 0.5
        return dot_product / (norm_a * norm_b)
    
    def search(self, query: str, k: int = 3) -> List[str]:
        """Busca documentos mais relevantes."""
        query_embedding = self._get_embedding(query)
        
        similarities = [
            (doc, self._cosine_similarity(query_embedding, emb))
            for doc, emb in zip(self.documents, self.embeddings)
        ]
        
        similarities.sort(key=lambda x: x[1], reverse=True)
        return [doc for doc, _ in similarities[:k]]
    
    def query(self, question: str) -> str:
        """Responde pergunta usando RAG."""
        relevant_docs = self.search(question)
        context = "\n\n".join(relevant_docs)
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {
                    "role": "system",
                    "content": f"Responda com base no contexto:\n{context}"
                },
                {"role": "user", "content": question}
            ]
        )
        
        return response.choices[0].message.content

6. "Implemente rate limiting para API de LLM"

import time
from collections import deque
from threading import Lock

class RateLimiter:
    """
    Rate limiter com sliding window.
    Limita requests por minuto.
    """
    
    def __init__(self, requests_per_minute: int):
        self.rpm = requests_per_minute
        self.window = 60  # segundos
        self.requests = deque()
        self.lock = Lock()
    
    def acquire(self) -> bool:
        """
        Tenta adquirir permissão para fazer request.
        Retorna True se permitido, False se deve esperar.
        """
        with self.lock:
            now = time.time()
            
            # Remove requests fora da janela
            while self.requests and self.requests[0] < now - self.window:
                self.requests.popleft()
            
            # Verifica se pode fazer request
            if len(self.requests) < self.rpm:
                self.requests.append(now)
                return True
            
            return False
    
    def wait_and_acquire(self):
        """
        Espera até poder fazer request.
        """
        while not self.acquire():
            time.sleep(0.1)

# Uso
limiter = RateLimiter(requests_per_minute=60)

def call_llm_with_rate_limit(prompt: str):
    limiter.wait_and_acquire()
    # fazer chamada para API
    return client.chat.completions.create(...)

Perguntas de System Design

7. "Desenhe um chatbot de suporte para e-commerce"

# System Design: Chatbot de Suporte E-commerce

## Requisitos
- 10.000 usuários simultâneos
- Responder sobre pedidos, produtos, devoluções
- Escalar para humano quando necessário
- Latência < 3s

## Arquitetura

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Frontend  │────▶│   API GW    │────▶│  Chat API   │
│   (React)   │     │  (Kong/AWS) │     │  (FastAPI)  │
└─────────────┘     └─────────────┘     └─────────────┘
                                               │
                    ┌──────────────────────────┼───────────┐
                    │                          │           │
                    ▼                          ▼           ▼
            ┌─────────────┐           ┌─────────────┐ ┌─────────┐
            │  Intent     │           │    RAG      │ │ Cache   │
            │ Classifier  │           │   Service   │ │ (Redis) │
            └─────────────┘           └─────────────┘ └─────────┘
                    │                          │
                    ▼                          ▼
            ┌─────────────┐           ┌─────────────┐
            │   Router    │           │ Vector DB   │
            │  (Agente)   │           │ (Pinecone)  │
            └─────────────┘           └─────────────┘
                    │
        ┌───────────┼───────────┐
        │           │           │
        ▼           ▼           ▼
   ┌─────────┐ ┌─────────┐ ┌─────────┐
   │ Orders  │ │Products │ │ Human   │
   │   API   │ │   API   │ │ Handoff │
   └─────────┘ └─────────┘ └─────────┘

## Componentes

1. Intent Classifier
   - Classifica: pedido, produto, devolução, outro
   - LLM com few-shot ou modelo fine-tuned

2. RAG Service
   - FAQs, políticas, info de produtos
   - Vector DB: Pinecone (managed, escala)

3. Router/Agente
   - Decide qual API chamar
   - Function calling do GPT-4

4. Human Handoff
   - Trigger: baixa confiança, pedido explícito
   - Integração com Zendesk/Intercom

## Otimizações

- Cache de respostas frequentes (Redis)
- Streaming de respostas (SSE)
- Fallback para modelo menor em picos
- Batch embeddings para RAG

8. "Como você escalaria esse sistema?"

Resposta ideal:

Estratégias de Scaling:

1. Horizontal Scaling
   - API stateless, escala com Kubernetes
   - Auto-scaling baseado em CPU/requests

2. Caching Inteligente
   - Cache de embeddings de perguntas frequentes
   - Cache de respostas (TTL curto)
   - Semantic cache: perguntas similares → mesma resposta

3. Queue para Picos
   - Requests em fila quando overloaded
   - Priorização por tipo de usuário

4. Multi-model Strategy
   - GPT-3.5 para queries simples
   - GPT-4 para complexas
   - Classifier decide qual usar

5. CDN para Assets
   - Histórico de chat cacheado
   - Static assets na edge

Métricas para Monitorar:
- Latência p50, p95, p99
- Taxa de erro
- Custos de API
- Satisfaction score

Perguntas Comportamentais

9. "Conte sobre um projeto desafiador com IA"

Framework STAR:

Estruture sua resposta:

Situação: Contexto do projeto
"Na empresa X, precisávamos criar um chatbot para 
atendimento que reduziria tickets em 40%."

Tarefa: Seu papel específico
"Eu era responsável pela arquitetura do sistema de RAG
e integração com nosso CRM."

Ação: O que você fez
"Implementei pipeline de ingestão de documentos,
otimizei chunking para melhorar retrieval,
e criei sistema de fallback para humanos."

Resultado: Métricas de sucesso
"Reduzimos tickets em 55%, latência média de 2s,
e satisfação do cliente subiu de 3.2 para 4.5/5."

10. "Como você se mantém atualizado em IA?"

Resposta ideal:

"Sigo pesquisadores no Twitter/X como Andrej Karpathy e Yann LeCun. Leio papers importantes quando saem (costumo ler o resumo e implementação, não matemática toda). Participo de comunidades como o Discord do LangChain. Faço projetos pessoais para testar novas ferramentas — recentemente experimentei com Agents usando CrewAI. E assino newsletters como The Batch do Andrew Ng."

Dicas Finais

• Pense em voz alta — entrevistadores querem ver seu raciocínio
• Admita quando não sabe — melhor que inventar
• Faça perguntas — clarificar requisitos mostra maturidade
• Pratique coding ao vivo — nervosismo é real, prática ajuda
• Prepare perguntas para eles — mostra interesse genuíno