Como colocar modelos de IA em produção: FastAPI, Docker, versionamento de modelos e prompts, monitoramento, CI/CD para ML e padrões de deploy para sistemas de IA.

MLOps e Deploy — Colocando IA em Produção

Meu caro buscador, o teste prático vai avaliar se você constrói algo que funciona. Mas o que separa um júnior de um pleno é saber que "funcionar na minha máquina" não é o suficiente.

Vou te mostrar como colocar um sistema de IA em produção — de verdade.

1. Servir Modelos com FastAPI

1.1 API básica

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from openai import AsyncOpenAI
import asyncio

app = FastAPI(title="AI Service", version="1.0.0")
client = AsyncOpenAI()

class ChatRequest(BaseModel):
    message: str
    model: str = "gpt-4o"
    temperature: float = 0.0

class ChatResponse(BaseModel):
    response: str
    model: str
    tokens_used: int

@app.post("/chat", response_model=ChatResponse)
async def chat(req: ChatRequest):
    try:
        result = await client.chat.completions.create(
            model=req.model,
            messages=[{"role": "user", "content": req.message}],
            temperature=req.temperature,
        )
        return ChatResponse(
            response=result.choices[0].message.content,
            model=result.model,
            tokens_used=result.usage.total_tokens,
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health():
    return {"status": "ok"}

1.2 Streaming (SSE)

from fastapi.responses import StreamingResponse
from openai import AsyncOpenAI

@app.post("/chat/stream")
async def chat_stream(req: ChatRequest):
    async def generate():
        stream = await client.chat.completions.create(
            model=req.model,
            messages=[{"role": "user", "content": req.message}],
            stream=True,
        )
        async for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"
        yield "data: [DONE]\n\n"

    return StreamingResponse(generate(), media_type="text/event-stream")

2. Docker

2.1 Dockerfile

FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

2.2 docker-compose.yml

version: "3.8"
services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - REDIS_URL=redis://redis:6379
    depends_on:
      - redis
      - chroma

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

  chroma:
    image: chromadb/chroma:latest
    ports:
      - "8001:8000"
    volumes:
      - chroma_data:/chroma/chroma

volumes:
  chroma_data:

3. Versionamento

3.1 Prompts como código

# prompts/v1/summarize.yaml
name: summarize
version: "1.0"
model: gpt-4o
temperature: 0
system: |
  Você é um assistente de resumo. Resuma o texto abaixo em no máximo 3 parágrafos.
  Mantenha os fatos principais e elimine redundâncias.
user: |
  Texto para resumo:
  {text}
evaluation:
  metrics: [faithfulness, conciseness]
  test_cases: 50

3.2 Versionar com git

prompts/
  ├── v1/
  │   ├── summarize.yaml
  │   └── classify.yaml
  ├── v2/
  │   ├── summarize.yaml  ← melhoria
  │   └── classify.yaml
  └── CHANGELOG.md

4. Monitoramento

4.1 O que monitorar

Métrica	Ferramenta	Alerta
Latência	Prometheus + Grafana	p95 > 5s
Taxa de erro	Logs estruturados	> 1%
Custo por requisição	Custom dashboard	> $0.10/request
Tokens por requisição	Logs	Média > 4000
Qualidade (faithfulness)	Ragas / LLM-as-judge	< 0.8

4.2 Logs estruturados

import structlog

logger = structlog.get_logger()

@app.post("/chat")
async def chat(req: ChatRequest):
    logger.info("chat_request", model=req.model, tokens=len(req.message.split()))
    # ... process ...
    logger.info("chat_response", tokens_used=result.usage.total_tokens, latency_ms=latency)

5. CI/CD para IA

5.1 Pipeline

# .github/workflows/ai-ci.yml
name: AI CI/CD
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: pip install -r requirements.txt
      - run: pytest tests/ --cov=app
      - run: promptfoo eval prompts/  # avalia prompts
      - run: ragas eval  # avalia RAG
  deploy:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - run: docker build -t ai-service .
      - run: docker push registry/ai-service

Dica Final

No teste prático, demonstre que pensa além do "funciona na minha máquina":

Dockerize seu projeto — mostra que pensa em deploy
Adicione healthcheck — mostra que pensa em monitoramento
Trate erros de API — mostra que pensa em resiliência
Versione prompts — mostra que pensa em manutenção
Inclua testes — mostra que pensa em qualidade

Cada uma dessas coisas adiciona pontos. Juntas, separam você dos demais.

MLOps e Deploy — Colocando IA em Produção

On this page