Como um engenheiro de IA trabalha no dia a dia: arquitetura de sistemas com LLMs, pipeline de dados, integração de modelos, avaliação contínua e padrões de código para projetos de IA.

Engenharia de IA na Prática — Do Protótipo ao Produto

Meu caro buscador, existe uma diferença enorme entre "fazer um chatbot com ChatGPT" e "ser engenheiro de IA". O primeiro é um tutorial. O segundo é uma profissão.

Vou te mostrar o que um engenheiro de IA realmente faz no dia a dia — e o que diferencia um júnior de um pleno/sênior.

1. O que um Engenheiro de IA Faz

1.1 As 5 responsabilidades principais

#	Responsabilidade	O que envolve
1	Integrar modelos	Chamar APIs de LLM, gerenciar tokens, tratar erros, fazer fallback
2	Construir pipelines	RAG, ETL de dados, embeddings, vector DBs
3	Avaliar qualidade	Métricas, testes, LLM-as-judge, A/B testing
4	Otimizar custo	Cache, roteamento de modelos, batch processing
5	Deploy e monitoramento	APIs, containers, logs, alertas de degradação

1.2 O que NÃO é engenharia de IA

Treinar modelo do zero (isso é ML Engineer / Researcher)
Fazer análise de dados (isso é Data Scientist)
Criar apresentações bonitas (isso é Product)
Apenas fazer prompt (isso é prompt engineering básico)

2. Arquitetura de um Sistema de IA

2.1 Stack típica

FRONTEND (Next.js / React)
       │
       ▼
API GATEWAY (FastAPI / Express)
       │
       ├── ROUTER DE MODELOS
       │     ├── OpenAI (GPT-4o)
       │     ├── Anthropic (Claude)
       │     └── Fallback (Groq / local)
       │
       ├── PIPELINE RAG
       │     ├── Document Loader
       │     ├── Chunker
       │     ├── Embedding (OpenAI / sentence-transformers)
       │     ├── Vector DB (Chroma / Qdrant / Pinecone)
       │     └── Retriever + Re-ranker
       │
       ├── AGENT RUNTIME
       │     ├── Tool Registry
       │     ├── Memory (Redis / Postgres)
       │     └── Orchestrator (LangGraph)
       │
       └── OBSERVABILIDADE
             ├── Logs estruturados
             ├── Tracing (LangSmith / Langfuse)
             └── Métricas de qualidade

2.2 Padrões de código

# Exemplo: API de chat com RAG (FastAPI + LangChain)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain.chains import RetrievalQA

app = FastAPI()

# Inicialização
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)
llm = ChatOpenAI(model="gpt-4o", temperature=0)
qa_chain = RetrievalQA.from_chain_type(llm, retriever=vectorstore.as_retriever())

class ChatRequest(BaseModel):
    question: str
    top_k: int = 5

class ChatResponse(BaseModel):
    answer: str
    sources: list[str]
    confidence: float

@app.post("/chat", response_model=ChatResponse)
async def chat(req: ChatRequest):
    try:
        result = qa_chain.invoke({"query": req.question})
        return ChatResponse(
            answer=result["result"],
            sources=[doc.metadata["source"] for doc in result["source_documents"]],
            confidence=0.85
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

3. Padrões que Toda Entrevista Testa

3.1 Tratamento de erros de API

import openai
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(min=1, max=10))
async def call_llm(prompt: str) -> str:
    try:
        response = await openai.ChatCompletion.acreate(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0,
            max_tokens=1000,
            timeout=30
        )
        return response.choices[0].message.content
    except openai.RateLimitError:
        raise  # retry will handle
    except openai.APIError as e:
        raise HTTPException(status_code=502, detail=f"LLM API error: {e}")

3.2 Structured Output

from pydantic import BaseModel
from openai import OpenAI

class AnalysisResult(BaseModel):
    sentiment: str  # "positive", "negative", "neutral"
    confidence: float
    key_topics: list[str]
    summary: str

client = OpenAI()
response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[{"role": "user", "content": f"Analise: {text}"}],
    response_format=AnalysisResult,
)
result = response.choices[0].message.parsed

3.3 Caching de respostas

import hashlib
import json
from functools import lru_cache

def cache_key(prompt: str, model: str, params: dict) -> str:
    content = json.dumps({"prompt": prompt, "model": model, "params": params}, sort_keys=True)
    return hashlib.sha256(content.encode()).hexdigest()

# Redis cache implementation
async def get_cached_response(prompt: str, model: str, params: dict) -> str | None:
    key = cache_key(prompt, model, params)
    return await redis.get(key)

async def set_cached_response(prompt: str, model: str, params: dict, response: str, ttl: int = 3600):
    key = cache_key(prompt, model, params)
    await redis.setex(key, ttl, response)

4. Como se Preparar para o Teste

4.1 Exercícios práticos

Exercício	O que testa
Construir API de chat com streaming	FastAPI, async, SSE
Implementar RAG do zero	Embeddings, vector DB, retrieval
Criar agent com 3 tools	Tool calling, LangChain, parsing
Avaliar qualidade de respostas	Métricas, LLM-as-judge
Containerizar com Docker	Dockerfile, docker-compose
Implementar cache de LLM	Redis, hash, TTL

4.2 Perguntas conceituais frequentes

"O que é temperature e como afeta as respostas?"
"Como você lida com context window limit?"
"Diferença entre embedding e fine-tuning?"
"Como você evitaria prompt injection?"
"O que é e como funciona function calling?"

Dica Final

O teste prático de engenharia de IA não avalia se você sabe decorar documentação. Avalia se você consegue construir algo que funciona, é robusto e é manutenível.

Mostre que você pensa em:

Erros (e o que acontece quando a API cai?)
Custo (você está mandando o contexto inteiro todo vez?)
Qualidade (como você sabe se a resposta é boa?)
Escalabilidade (e se 1000 pessoas usarem ao mesmo tempo?)

Se você responder essas 4 perguntas no teste, já se diferencia de 80% dos candidatos.

Engenharia de IA na Prática — Do Protótipo ao Produto

On this page