FastAPI para Dados e IA 🚀

📋 Sobre o Projeto

Este projeto foi criado como material de apoio para o artigo FastAPI para Dados e IA: Do Zero à Produção com OpenAI e Groq e demonstra como construir APIs robustas para servir modelos de IA, com exemplos práticos de:

• ✅ Chat completions com OpenAI e Groq
• ✅ Geração de embeddings para RAG
• ✅ Streaming de respostas em tempo real
• ✅ Validação de dados com Pydantic
• ✅ Documentação automática com Swagger UI
• ✅ Arquitetura modular e escalável

🛠️ Tecnologias Utilizadas

• FastAPI - Framework web moderno e assíncrono
• Uvicorn - Servidor ASGI de alta performance
• OpenAI - Integração com GPT-4, GPT-3.5 e embeddings
• Groq - Inferência ultrarrápida com Llama, Mixtral e Gemma
• Pydantic - Validação de dados e configurações
• Python 3.10+ - Linguagem de programação

📁 Estrutura do Projeto

fastapi-ia-demo/
├── app/
│   ├── __init__.py
│   ├── main.py              # Aplicação principal
│   ├── config.py            # Configurações e variáveis de ambiente
│   ├── models/
│   │   ├── __init__.py
│   │   └── schemas.py       # Modelos Pydantic
│   └── routers/
│       ├── __init__.py
│       ├── openai_router.py # Endpoints OpenAI
│       └── groq_router.py   # Endpoints Groq
├── .env.example             # Template de variáveis de ambiente
├── .gitignore
├── requirements.txt
└── README.md

🚀 Instalação e Configuração

1. Clone o repositório

git clone https://github.com/seu-usuario/fastapi-ia-demo.git
cd fastapi-ia-demo

2. Crie um ambiente virtual

python -m venv venv
source venv/bin/activate  # Linux/Mac
# ou
venv\Scripts\activate  # Windows

3. Instale as dependências

pip install -r requirements.txt

4. Configure as variáveis de ambiente

Copie o arquivo .env.example para .env e preencha com suas chaves de API:

cp .env.example .env

Edite o arquivo .env:

OPENAI_API_KEY=sk-...  # Sua chave da OpenAI
GROQ_API_KEY=gsk_...   # Sua chave do Groq

Como obter as chaves:

• OpenAI: https://platform.openai.com/api-keys
• Groq: https://console.groq.com/keys

5. Execute a aplicação

uvicorn app.main:app --reload --host 0.0.0.0 --port 8000

A API estará disponível em:

• API: http://localhost:8000
• Documentação Swagger: http://localhost:8000/docs
• Documentação ReDoc: http://localhost:8000/redoc

📚 Endpoints Disponíveis

Endpoints Gerais

• GET / - Informações da API
• GET /health - Health check

OpenAI

• POST /openai/chat - Chat completion
• POST /openai/chat/stream - Chat com streaming
• POST /openai/embeddings - Geração de embeddings

Groq

• POST /groq/chat - Chat completion
• GET /groq/models - Lista modelos disponíveis

Unificado

• POST /chat/unified?provider=openai - Endpoint unificado

💡 Exemplos de Uso

Chat com OpenAI

curl -X POST "http://localhost:8000/openai/chat" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "system", "content": "Você é um especialista em dados."},
      {"role": "user", "content": "O que é um Data Lake?"}
    ],
    "temperature": 0.7
  }'

Chat com Groq

curl -X POST "http://localhost:8000/groq/chat" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Explique Apache Spark em 3 frases."}
    ],
    "model": "llama-3.1-8b-instant"
  }'

Gerar Embeddings

curl -X POST "http://localhost:8000/openai/embeddings" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "FastAPI é um framework moderno para construir APIs"
  }'

Usando Python

import requests

url = "http://localhost:8000/openai/chat"
payload = {
    "messages": [
        {"role": "user", "content": "O que é FastAPI?"}
    ],
    "temperature": 0.7
}

response = requests.post(url, json=payload)
print(response.json())

🧪 Testando com a Documentação Interativa

Acesse http://localhost:8000/docs e você terá uma interface interativa onde pode:

1. Ver todos os endpoints disponíveis
2. Testar requisições diretamente no navegador
3. Ver os schemas de entrada e saída
4. Visualizar exemplos de respostas

🔧 Modelos Disponíveis

OpenAI

• gpt-4o-mini - Rápido e econômico (padrão)
• gpt-4o - Mais capaz
• gpt-4-turbo - Ótimo custo-benefício
• text-embedding-3-small - Para embeddings

Groq

• llama-3.1-70b-versatile - Melhor equilíbrio (padrão)
• llama-3.1-8b-instant - Extremamente rápido
• mixtral-8x7b-32768 - Contexto longo
• gemma2-9b-it - Modelo do Google

🚀 Deploy

Docker (Recomendado)

FROM python:3.10-slim

WORKDIR /app

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

COPY app/ ./app/

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

docker build -t fastapi-ia-demo .
docker run -p 8000:8000 --env-file .env fastapi-ia-demo

Railway, Render ou Heroku

1. Adicione um Procfile:

web: uvicorn app.main:app --host 0.0.0.0 --port $PORT

2. Configure as variáveis de ambiente no painel da plataforma

3. Deploy!

🤝 Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para:

1. Fazer um fork do projeto
2. Criar uma branch para sua feature (git checkout -b feature/AmazingFeature)
3. Commit suas mudanças (git commit -m 'Add some AmazingFeature')
4. Push para a branch (git push origin feature/AmazingFeature)
5. Abrir um Pull Request

📝 Licença

Este projeto está sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.

👤 Autor

Alexsander Valente

• Blog: alexsander.app.br
• LinkedIn: linkedin.com/in/alexsander-valente
• GitHub: @alevtelles

📚 Recursos Adicionais

• Documentação FastAPI
• OpenAI API Reference
• Groq Documentation
• Pydantic Documentation

⭐ Se este projeto foi útil para você, considere dar uma estrela no GitHub!