Combinar C#, Java, Python, Banco de Dados e Inteligência Artificial (IA)
Abordagem muito poderosa e usada em sistemas modernos, especialmente em aplicações corporativas, SaaS e produtos inteligentes. Vou te mostrar como essas tecnologias se encaixam na prática, com exemplos claros.
🔗 Visão geral da arquitetura integrada
Imagine o sistema como camadas especializadas, onde cada linguagem faz o que sabe fazer melhor.
🧠 Papel de cada tecnologia
🟦 C# (Backend corporativo e APIs)
Usado para:
APIs REST (ASP.NET Core)
Sistemas empresariais
Integração com serviços de IA
Aplicações desktop (WPF, WinForms)
📌 Exemplo:
API em C# que recebe dados do usuário e envia para um modelo de IA feito em Python.
☕ Java (Escalabilidade e robustez)
Usado para:
Microserviços (Spring Boot)
Sistemas bancários e grandes plataformas
Processamento de alto volume de dados
📌 Exemplo:
Serviço Java que gerencia autenticação, filas e regras de negócio.
🐍 Python (IA, Machine Learning e automação)
Usado para:
Treinar modelos de IA
Análise de dados
Deep Learning (TensorFlow, PyTorch)
APIs de IA (FastAPI, Flask)
📌 Exemplo:
Modelo de IA que prevê comportamento do usuário ou faz reconhecimento de imagem.
🗄️ Banco de Dados (Cérebro do sistema)
Tipos mais comuns:
SQL: PostgreSQL, MySQL, SQL Server
NoSQL: MongoDB, Redis
Usado para:
Armazenar dados de usuários
Salvar resultados da IA
Histórico e logs
🤖 Inteligência Artificial (IA)
Usada para:
Recomendação de produtos
Chatbots
Previsões
Visão computacional
Análise de texto
📌 A IA geralmente é:
Treinada em Python
Consumida por C# ou Java via API
🔄 Como tudo se comunica (na prática)
Frontend (Web / App)
↓
C# ou Java (API principal)
↓
Banco de Dados
↓
Python (IA via API REST)
↓
Resposta inteligente
📡 Comunicação feita via:
HTTP/REST
JSON
Filas (RabbitMQ, Kafka)
💡 Exemplo real de projeto
🎯 Sistema inteligente de recomendação
C# → API principal
Java → Microserviço de usuários
Python → IA que recomenda produtos
PostgreSQL → Banco de dados
IA → Machine Learning com histórico de compras
🚀 Vantagens dessa combinação
✅ Cada linguagem faz o que faz melhor
✅ Sistema escalável
✅ IA desacoplada do backend
✅ Fácil manutenção
✅ Padrão usado por grandes empresas
📚 Caminho recomendado para estudar
1️⃣ Banco de Dados (SQL + modelagem)
2️⃣ Lógica de programação
3️⃣ Python (IA e dados)
4️⃣ C# ou Java (backend)
5️⃣ APIs REST
6️⃣ Integração com IA
Se quiser, posso:
Criar um projeto exemplo completo
Montar um roadmap de estudos
Mostrar código real de integração
Criar uma imagem conceitual personalizada
👉 O que você prefere?
# 🌟 **Sistema Multiplataforma: C# + Java + Python + Banco de Dados + IA**
## **📌 ARQUITETURA DO SISTEMA INTEGRADO**
### **🎯 Visão Geral do Sistema:**
```
┌─────────────────────────────────────────────────────────────┐
│ SISTEMA DE RECOMENDAÇÃO │
│ INTELIGENTE MULTIPLATAFORMA │
└─────────────────────────────────────────────────────────────┘
Frontend (C#/.NET) Backend (Java/Spring)
┌──────────────────┐ ┌─────────────────────┐
│ Desktop App │◄───────►│ REST API │
│ Windows Forms │ HTTP │ Microserviços │
│ WPF │ │ Spring Boot │
└──────────────────┘ └─────────────────────┘
│ │
│ │
┌───────▼───────────────────────┬──────▼──────────────┐
│ Banco de Dados (PostgreSQL) │ Sistema de IA │
│ ┌──────────────────────────┐ │ (Python/FastAPI) │
│ │ Tabelas: │ │ ┌──────────────┐ │
│ │ • Usuários │ │ │ ML Models │ │
│ │ • Produtos │ │ │ TensorFlow │ │
│ │ • Avaliações │ │ │ Scikit-learn │ │
│ │ • Recomendações │ │ └──────────────┘ │
│ │ • Logs de IA │ │ │ │
│ └──────────────────────────┘ │ │ │
│ │ │ ┌─────▼──────┐ │
│ └─────────────────────┼─►│ Redis │ │
│ │ │ Cache │ │
│ │ └────────────┘ │
└───────────────────────────────┴───────────────────┘
```
---
## **1. BANCO DE DADOS (POSTGRESQL)**
### **Schema do Banco:**
```sql
-- database_schema.sql
-- Tabela de Usuários
CREATE TABLE usuarios (
id SERIAL PRIMARY KEY,
nome VARCHAR(100) NOT NULL,
email VARCHAR(150) UNIQUE NOT NULL,
idade INTEGER,
pais VARCHAR(50),
data_cadastro TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
preferencias JSONB
);
-- Tabela de Produtos
CREATE TABLE produtos (
id SERIAL PRIMARY KEY,
nome VARCHAR(200) NOT NULL,
categoria VARCHAR(100),
preco DECIMAL(10,2),
descricao TEXT,
caracteristicas JSONB,
data_cadastro TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
-- Tabela de Avaliações
CREATE TABLE avaliacoes (
id SERIAL PRIMARY KEY,
usuario_id INTEGER REFERENCES usuarios(id),
produto_id INTEGER REFERENCES produtos(id),
rating INTEGER CHECK (rating >= 1 AND rating <= 5),
comentario TEXT,
data_avaliacao TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UNIQUE(usuario_id, produto_id)
);
-- Tabela de Recomendações
CREATE TABLE recomendacoes (
id SERIAL PRIMARY KEY,
usuario_id INTEGER REFERENCES usuarios(id),
produto_id INTEGER REFERENCES produtos(id),
score DECIMAL(5,4),
algoritmo VARCHAR(50),
data_geracao TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
exibida BOOLEAN DEFAULT FALSE,
clicada BOOLEAN DEFAULT FALSE
);
-- Tabela de Logs de IA
CREATE TABLE logs_ia (
id SERIAL PRIMARY KEY,
algoritmo VARCHAR(100),
acao VARCHAR(100),
parametros JSONB,
resultado JSONB,
tempo_execucao DECIMAL(10,4),
data_execucao TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
-- Índices para performance
CREATE INDEX idx_avaliacoes_usuario ON avaliacoes(usuario_id);
CREATE INDEX idx_avaliacoes_produto ON avaliacoes(produto_id);
CREATE INDEX idx_recomendacoes_usuario ON recomendacoes(usuario_id);
CREATE INDEX idx_produtos_categoria ON produtos(categoria);
```
---
## **2. BACKEND JAVA (SPRING BOOT)**
### **Estrutura do Projeto:**
```
backend-java/
├── src/main/java/com/sistemaia/
│ ├── config/
│ ├── controller/
│ ├── service/
│ ├── repository/
│ ├── model/
│ ├── dto/
│ └── Security/
├── src/main/resources/
│ └── application.properties
└── pom.xml
```
### **Application Properties:**
```properties
# application.properties
server.port=8080
spring.application.name=sistema-ia-backend
# Database
spring.datasource.url=jdbc:postgresql://localhost:5432/sistema_ia
spring.datasource.username=postgres
spring.datasource.password=senha123
spring.jpa.hibernate.ddl-auto=update
# Redis Cache
spring.redis.host=localhost
spring.redis.port=6379
# Python AI Service
ai.service.url=http://localhost:5000
```
### **Modelo Usuario:**
```java
// Usuario.java
package com.sistemaia.model;
import javax.persistence.*;
import java.time.LocalDateTime;
@Entity
@Table(name = "usuarios")
public class Usuario {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String nome;
private String email;
private Integer idade;
private String pais;
@Column(columnDefinition = "jsonb")
private String preferencias;
private LocalDateTime dataCadastro;
// Getters e Setters
// Construtores
}
```
### **Repositório:**
```java
// UsuarioRepository.java
package com.sistemaia.repository;
import com.sistemaia.model.Usuario;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
Usuario findByEmail(String email);
List<Usuario> findByPais(String pais);
@Query("SELECT u FROM Usuario u WHERE SIZE(u.avaliacoes) >= :minAvaliacoes")
List<Usuario> findUsuariosAtivos(int minAvaliacoes);
}
```
### **Service:**
```java
// RecomendacaoService.java
package com.sistemaia.service;
import com.sistemaia.dto.RecomendacaoDTO;
import com.sistemaia.model.Recomendacao;
import com.sistemaia.model.Usuario;
import com.sistemaia.repository.RecomendacaoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class RecomendacaoService {
@Autowired
private RecomendacaoRepository recomendacaoRepository;
@Autowired
private RestTemplate restTemplate;
@Value("${ai.service.url}")
private String aiServiceUrl;
@Cacheable(value = "recomendacoes", key = "#usuarioId")
public List<RecomendacaoDTO> getRecomendacoes(Long usuarioId) {
// Verificar cache primeiro
List<Recomendacao> existentes = recomendacaoRepository
.findByUsuarioIdAndExibidaFalse(usuarioId);
if (!existentes.isEmpty()) {
return convertToDTO(existentes);
}
// Chamar serviço de IA Python
String url = aiServiceUrl + "/api/recomendar/" + usuarioId;
RecomendacaoDTO[] recomendacoes = restTemplate
.getForObject(url, RecomendacaoDTO[].class);
// Salvar no banco
List<Recomendacao> novasRecomendacoes = Arrays.stream(recomendacoes)
.map(dto -> convertToEntity(dto, usuarioId))
.collect(Collectors.toList());
recomendacaoRepository.saveAll(novasRecomendacoes);
return Arrays.asList(recomendacoes);
}
public void registrarClique(Long recomendacaoId) {
recomendacaoRepository.updateClicada(recomendacaoId, true);
}
private List<RecomendacaoDTO> convertToDTO(List<Recomendacao> recomendacoes) {
return recomendacoes.stream()
.map(this::convertToDTO)
.collect(Collectors.toList());
}
private RecomendacaoDTO convertToDTO(Recomendacao recomendacao) {
RecomendacaoDTO dto = new RecomendacaoDTO();
dto.setProdutoId(recomendacao.getProduto().getId());
dto.setProdutoNome(recomendacao.getProduto().getNome());
dto.setScore(recomendacao.getScore());
dto.setAlgoritmo(recomendacao.getAlgoritmo());
return dto;
}
private Recomendacao convertToEntity(RecomendacaoDTO dto, Long usuarioId) {
Recomendacao recomendacao = new Recomendacao();
// Configurar entidade
return recomendacao;
}
}
```
### **Controller REST:**
```java
// RecomendacaoController.java
package com.sistemaia.controller;
import com.sistemaia.dto.RecomendacaoDTO;
import com.sistemaia.service.RecomendacaoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/recomendacoes")
@CrossOrigin(origins = "*")
public class RecomendacaoController {
@Autowired
private RecomendacaoService recomendacaoService;
@GetMapping("/usuario/{usuarioId}")
public ResponseEntity<List<RecomendacaoDTO>> getRecomendacoes(
@PathVariable Long usuarioId) {
List<RecomendacaoDTO> recomendacoes =
recomendacaoService.getRecomendacoes(usuarioId);
return ResponseEntity.ok(recomendacoes);
}
@PostMapping("/{recomendacaoId}/clique")
public ResponseEntity<Void> registrarClique(
@PathVariable Long recomendacaoId) {
recomendacaoService.registrarClique(recomendacaoId);
return ResponseEntity.ok().build();
}
@GetMapping("/estatisticas/{usuarioId}")
public ResponseEntity<EstatisticasDTO> getEstatisticas(
@PathVariable Long usuarioId) {
// Retornar estatísticas de acerto do sistema
return ResponseEntity.ok(new EstatisticasDTO());
}
}
```
### **Configuração do RestTemplate:**
```java
// AppConfig.java
package com.sistemaia.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.cache.annotation.EnableCaching;
@Configuration
@EnableCaching
public class AppConfig {
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
}
```
---
## **3. SISTEMA DE IA EM PYTHON (FASTAPI)**
### **Estrutura do Projeto:**
```
ia-python/
├── app/
│ ├── __init__.py
│ ├── main.py
│ ├── models/
│ ├── services/
│ ├── database.py
│ └── schemas.py
├── ml_models/
├── requirements.txt
└── Dockerfile
```
### **requirements.txt:**
```txt
fastapi==0.104.1
uvicorn==0.24.0
sqlalchemy==2.0.23
psycopg2-binary==2.9.9
pandas==2.1.3
numpy==1.24.3
scikit-learn==1.3.2
tensorflow==2.14.0
redis==5.0.1
joblib==1.3.2
```
### **API Principal:**
```python
# main.py
from fastapi import FastAPI, HTTPException, Depends
from fastapi.middleware.cors import CORSMiddleware
from sqlalchemy.orm import Session
import pandas as pd
import numpy as np
import pickle
import redis
import json
from datetime import datetime
from database import SessionLocal, engine
from schemas import RecomendacaoRequest, RecomendacaoResponse
from services.recomendacao_service import RecomendacaoService
from services.ml_service import MLService
app = FastAPI(title="Sistema de IA - Recomendações")
# CORS
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# Dependência do banco de dados
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
# Conexão Redis
redis_client = redis.Redis(host='localhost', port=6379, db=0)
# Inicializar serviços
ml_service = MLService()
recomendacao_service = RecomendacaoService(ml_service)
@app.get("/")
async def root():
return {"message": "Sistema de IA - API de Recomendações"}
@app.get("/api/recomendar/{usuario_id}")
async def recomendar(usuario_id: int, db: Session = Depends(get_db)):
"""Endpoint principal de recomendações"""
# Verificar cache
cache_key = f"recomendacoes:{usuario_id}"
cached = redis_client.get(cache_key)
if cached:
print(f"Cache hit para usuário {usuario_id}")
return json.loads(cached)
# Buscar dados do usuário
usuario_data = recomendacao_service.buscar_dados_usuario(db, usuario_id)
if not usuario_data:
raise HTTPException(status_code=404, detail="Usuário não encontrado")
# Gerar recomendações
recomendacoes = recomendacao_service.gerar_recomendacoes(db, usuario_data)
# Salvar no cache (expira em 1 hora)
redis_client.setex(cache_key, 3600, json.dumps(recomendacoes))
# Log da execução
recomendacao_service.log_execucao(usuario_id, len(recomendacoes))
return recomendacoes
@app.post("/api/train/model")
async def train_model(model_type: str = "collaborative"):
"""Treinar modelo de machine learning"""
try:
resultado = ml_service.train_model(model_type)
return {
"status": "success",
"model_type": model_type,
"metrics": resultado
}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/health")
async def health_check():
"""Health check do sistema de IA"""
return {
"status": "healthy",
"timestamp": datetime.now().isoformat(),
"models_loaded": ml_service.models_loaded()
}
```
### **Serviço de ML:**
```python
# services/ml_service.py
import pickle
import numpy as np
import pandas as pd
from sklearn.neighbors import NearestNeighbors
from sklearn.decomposition import TruncatedSVD
from sklearn.metrics.pairwise import cosine_similarity
from sqlalchemy import create_engine
import warnings
warnings.filterwarnings('ignore')
class MLService:
def __init__(self):
self.models = {}
self.load_models()
def load_models(self):
"""Carregar modelos pré-treinados"""
try:
# Modelo de filtragem colaborativa
with open('ml_models/collaborative_filtering.pkl', 'rb') as f:
self.models['collaborative'] = pickle.load(f)
# Modelo baseado em conteúdo
with open('ml_models/content_based.pkl', 'rb') as f:
self.models['content'] = pickle.load(f)
print("Modelos carregados com sucesso")
except:
print("Modelos não encontrados, será necessário treinar")
def train_model(self, model_type: str):
"""Treinar novo modelo"""
if model_type == "collaborative":
return self._train_collaborative_filtering()
elif model_type == "content":
return self._train_content_based()
else:
raise ValueError(f"Tipo de modelo não suportado: {model_type}")
def _train_collaborative_filtering(self):
"""Treinar filtragem colaborativa"""
# Conectar ao banco
engine = create_engine('postgresql://postgres:senha123@localhost/sistema_ia')
# Buscar avaliações
query = """
SELECT usuario_id, produto_id, rating
FROM avaliacoes
WHERE rating IS NOT NULL
"""
df = pd.read_sql(query, engine)
# Criar matriz usuário-item
user_item_matrix = df.pivot_table(
index='usuario_id',
columns='produto_id',
values='rating'
).fillna(0)
# Aplicar SVD para redução dimensional
svd = TruncatedSVD(n_components=50, random_state=42)
user_features = svd.fit_transform(user_item_matrix)
# Treinar modelo KNN
model = NearestNeighbors(
n_neighbors=10,
metric='cosine',
algorithm='brute'
)
model.fit(user_features)
# Salvar modelo
with open('ml_models/collaborative_filtering.pkl', 'wb') as f:
pickle.dump({
'model': model,
'svd': svd,
'user_item_matrix': user_item_matrix,
'user_features': user_features
}, f)
return {
"n_users": len(user_item_matrix),
"n_items": len(user_item_matrix.columns),
"explained_variance": svd.explained_variance_ratio_.sum()
}
def _train_content_based(self):
"""Treinar modelo baseado em conteúdo"""
engine = create_engine('postgresql://postgres:senha123@localhost/sistema_ia')
# Buscar produtos e características
query = """
SELECT p.id, p.nome, p.categoria, p.caracteristicas
FROM produtos p
"""
produtos = pd.read_sql(query, engine)
# Processar características (simplificado)
# Na prática, você usaria NLP para extrair features
# Vetorização simples (one-hot para categorias)
from sklearn.preprocessing import MultiLabelBinarizer
mlb = MultiLabelBinarizer()
categories = produtos['categoria'].apply(lambda x: [x])
category_features = mlb.fit_transform(categories)
# Salvar modelo
with open('ml_models/content_based.pkl', 'wb') as f:
pickle.dump({
'mlb': mlb,
'product_features': category_features,
'product_ids': produtos['id'].values
}, f)
return {
"n_products": len(produtos),
"n_features": category_features.shape[1]
}
def predict_collaborative(self, user_id: int, n_recommendations: int = 10):
"""Fazer previsões usando filtragem colaborativa"""
if 'collaborative' not in self.models:
raise ValueError("Modelo colaborativo não carregado")
model_data = self.models['collaborative']
user_item_matrix = model_data['user_item_matrix']
# Verificar se usuário existe na matriz
if user_id not in user_item_matrix.index:
return self._get_popular_products(n_recommendations)
# Encontrar usuários similares
user_idx = list(user_item_matrix.index).index(user_id)
user_vector = model_data['user_features'][user_idx].reshape(1, -1)
distances, indices = model_data['model'].kneighbors(
user_vector,
n_neighbors=n_recommendations + 5
)
# Recomendar produtos que usuários similares gostaram
similar_users = user_item_matrix.iloc[indices[0]].index
recommendations = {}
for sim_user in similar_users:
if sim_user == user_id:
continue
user_ratings = user_item_matrix.loc[sim_user]
top_products = user_ratings[user_ratings > 3].index
for product in top_products:
if product not in user_item_matrix.loc[user_id] or \
user_item_matrix.loc[user_id, product] == 0:
recommendations[product] = recommendations.get(product, 0) + 1
# Ordenar por frequência
sorted_recs = sorted(
recommendations.items(),
key=lambda x: x[1],
reverse=True
)[:n_recommendations]
return [prod_id for prod_id, _ in sorted_recs]
def _get_popular_products(self, n: int = 10):
"""Retornar produtos populares (fallback)"""
# Consulta SQL para produtos mais bem avaliados
query = """
SELECT p.id, AVG(a.rating) as avg_rating
FROM produtos p
JOIN avaliacoes a ON p.id = a.produto_id
GROUP BY p.id
ORDER BY avg_rating DESC
LIMIT %s
"""
engine = create_engine('postgresql://postgres:senha123@localhost/sistema_ia')
df = pd.read_sql(query, engine, params=(n,))
return df['id'].tolist()
```
### **Serviço de Recomendação:**
```python
# services/recomendacao_service.py
from sqlalchemy.orm import Session
from sqlalchemy import text
import pandas as pd
from typing import List, Dict, Any
import numpy as np
class RecomendacaoService:
def __init__(self, ml_service):
self.ml_service = ml_service
def buscar_dados_usuario(self, db: Session, usuario_id: int) -> Dict:
"""Buscar dados do usuário e seu histórico"""
# Buscar usuário
user_query = text("""
SELECT id, nome, idade, pais, preferencias
FROM usuarios
WHERE id = :user_id
""")
usuario = db.execute(user_query, {"user_id": usuario_id}).fetchone()
if not usuario:
return None
# Buscar histórico de avaliações
ratings_query = text("""
SELECT produto_id, rating
FROM avaliacoes
WHERE usuario_id = :user_id
""")
ratings = db.execute(ratings_query, {"user_id": usuario_id}).fetchall()
return {
"usuario": dict(usuario),
"historico": [dict(r) for r in ratings]
}
def gerar_recomendacoes(self, db: Session, usuario_data: Dict) -> List[Dict]:
"""Gerar recomendações usando múltiplos algoritmos"""
usuario_id = usuario_data["usuario"]["id"]
recomendacoes = []
# 1. Filtragem colaborativa
try:
collaborative_recs = self.ml_service.predict_collaborative(
usuario_id, n_recommendations=5
)
recomendacoes.extend([
{
"produto_id": prod_id,
"score": 0.9 - (i * 0.1), # Score decrescente
"algoritmo": "collaborative_filtering",
"rank": i + 1
}
for i, prod_id in enumerate(collaborative_recs)
])
except Exception as e:
print(f"Erro filtragem colaborativa: {e}")
# 2. Baseado em conteúdo (se tiver histórico)
if usuario_data["historico"]:
content_recs = self._get_content_recommendations(
db, usuario_data, n_recommendations=5
)
recomendacoes.extend(content_recs)
# 3. Produtos populares (fallback)
popular_recs = self._get_popular_recommendations(db, n_recommendations=5)
recomendacoes.extend(popular_recs)
# Remover duplicatas e ordenar por score
seen = set()
unique_recomendacoes = []
for rec in sorted(recomendacoes, key=lambda x: x["score"], reverse=True):
if rec["produto_id"] not in seen:
seen.add(rec["produto_id"])
unique_recomendacoes.append(rec)
if len(unique_recomendacoes) >= 10:
break
# Buscar detalhes dos produtos
return self._enrich_recommendations(db, unique_recomendacoes)
def _enrich_recommendations(self, db: Session, recomendacoes: List) -> List[Dict]:
"""Adicionar informações dos produtos às recomendações"""
if not recomendacoes:
return []
product_ids = [r["produto_id"] for r in recomendacoes]
query = text("""
SELECT id, nome, categoria, preco
FROM produtos
WHERE id IN :product_ids
""")
# SQLAlchemy precisa de tupla para IN clause
products = db.execute(
query,
{"product_ids": tuple(product_ids)}
).fetchall()
product_map = {p.id: dict(p) for p in products}
# Combinar informações
enriched = []
for rec in recomendacoes:
product_info = product_map.get(rec["produto_id"], {})
enriched.append({
**rec,
"produto_nome": product_info.get("nome", "Desconhecido"),
"categoria": product_info.get("categoria"),
"preco": float(product_info.get("preco", 0)) if product_info.get("preco") else None
})
return enriched
def log_execucao(self, usuario_id: int, n_recomendacoes: int):
"""Registrar log da execução"""
# Em produção, salvaria no banco de dados
print(f"Log: Recomendações geradas para usuário {usuario_id} - {n_recomendacoes} itens")
```
---
## **4. FRONTEND C# (WPF/WINFORMS)**
### **Estrutura do Projeto:**
```
SistemaIA.Desktop/
├── Models/
├── ViewModels/
├── Views/
├── Services/
├── Utils/
└── App.xaml
```
### **Modelo de Dados:**
```csharp
// Recomendacao.cs
namespace SistemaIA.Desktop.Models
{
public class Recomendacao
{
public int ProdutoId { get; set; }
public string ProdutoNome { get; set; }
public string Categoria { get; set; }
public decimal? Preco { get; set; }
public double Score { get; set; }
public string Algoritmo { get; set; }
public DateTime DataGeracao { get; set; }
}
public class Usuario
{
public int Id { get; set; }
public string Nome { get; set; }
public string Email { get; set; }
public int? Idade { get; set; }
public string Pais { get; set; }
public List<Avaliacao> Avaliacoes { get; set; } = new();
}
}
```
### **Service HTTP:**
```csharp
// ApiService.cs
using System.Net.Http;
using System.Net.Http.Json;
using System.Threading.Tasks;
namespace SistemaIA.Desktop.Services
{
public interface IApiService
{
Task<List<Recomendacao>> GetRecomendacoesAsync(int usuarioId);
Task RegistrarCliqueAsync(int recomendacaoId);
Task<Usuario> GetUsuarioAsync(int usuarioId);
}
public class ApiService : IApiService
{
private readonly HttpClient _httpClient;
private const string BaseUrl = "http://localhost:8080/api";
public ApiService()
{
_httpClient = new HttpClient
{
BaseAddress = new Uri(BaseUrl)
};
}
public async Task<List<Recomendacao>> GetRecomendacoesAsync(int usuarioId)
{
try
{
var response = await _httpClient
.GetAsync($"{BaseUrl}/recomendacoes/usuario/{usuarioId}");
response.EnsureSuccessStatusCode();
var recomendacoes = await response.Content
.ReadFromJsonAsync<List<Recomendacao>>();
return recomendacoes ?? new List<Recomendacao>();
}
catch (HttpRequestException ex)
{
// Log error
Console.WriteLine($"Erro ao buscar recomendações: {ex.Message}");
return new List<Recomendacao>();
}
}
public async Task RegistrarCliqueAsync(int recomendacaoId)
{
try
{
var response = await _httpClient
.PostAsync($"{BaseUrl}/recomendacoes/{recomendacaoId}/clique", null);
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
Console.WriteLine($"Erro ao registrar clique: {ex.Message}");
}
}
public async Task<Usuario> GetUsuarioAsync(int usuarioId)
{
try
{
var response = await _httpClient
.GetAsync($"{BaseUrl}/usuarios/{usuarioId}");
response.EnsureSuccessStatusCode();
return await response.Content.ReadFromJsonAsync<Usuario>();
}
catch
{
return null;
}
}
}
}
```
### **View Model:**
```csharp
// MainViewModel.cs
using System.Collections.ObjectModel;
using System.Windows.Input;
using SistemaIA.Desktop.Models;
using SistemaIA.Desktop.Services;
namespace SistemaIA.Desktop.ViewModels
{
public class MainViewModel : ObservableObject
{
private readonly IApiService _apiService;
private Usuario _usuario;
private bool _isLoading;
public Usuario Usuario
{
get => _usuario;
set => SetProperty(ref _usuario, value);
}
public bool IsLoading
{
get => _isLoading;
set => SetProperty(ref _isLoading, value);
}
public ObservableCollection<Recomendacao> Recomendacoes { get; }
= new ObservableCollection<Recomendacao>();
public ICommand CarregarRecomendacoesCommand { get; }
public ICommand ItemClicadoCommand { get; }
public MainViewModel(IApiService apiService)
{
_apiService = apiService;
CarregarRecomendacoesCommand = new RelayCommand(async () =>
await CarregarRecomendacoes());
ItemClicadoCommand = new RelayCommand<Recomendacao>(async (rec) =>
await ItemClicado(rec));
// Carregar usuário padrão (em produção seria login)
CarregarUsuario(1);
}
private async void CarregarUsuario(int usuarioId)
{
IsLoading = true;
try
{
Usuario = await _apiService.GetUsuarioAsync(usuarioId);
await CarregarRecomendacoes();
}
finally
{
IsLoading = false;
}
}
private async Task CarregarRecomendacoes()
{
if (Usuario == null) return;
IsLoading = true;
Recomendacoes.Clear();
try
{
var recomendacoes = await _apiService
.GetRecomendacoesAsync(Usuario.Id);
foreach (var rec in recomendacoes)
{
Recomendacoes.Add(rec);
}
}
finally
{
IsLoading = false;
}
}
private async Task ItemClicado(Recomendacao recomendacao)
{
if (recomendacao == null) return;
// Registrar clique no backend
await _apiService.RegistrarCliqueAsync(recomendacao.ProdutoId);
// Abrir detalhes do produto
MessageBox.Show($"Produto: {recomendacao.ProdutoNome}\n" +
$"Score: {recomendacao.Score:P2}\n" +
$"Algoritmo: {recomendacao.Algoritmo}",
"Detalhes do Produto");
}
}
}
```
### **View XAML:**
```xml
<!-- MainWindow.xaml -->
<Window x:Class="SistemaIA.Desktop.Views.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Sistema de Recomendações IA" Height="600" Width="800">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<!-- Cabeçalho -->
<Border Background="#2c3e50" Padding="20">
<StackPanel>
<TextBlock Text="Sistema Inteligente de Recomendações"
FontSize="24" FontWeight="Bold" Foreground="White"/>
<TextBlock Text="{Binding Usuario.Nome, StringFormat='Bem-vindo, {0}!'}"
FontSize="14" Foreground="#ecf0f1" Margin="0,10,0,0"/>
</StackPanel>
</Border>
<!-- Conteúdo -->
<Grid Grid.Row="1" Margin="20">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="2*"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<!-- Lista de Recomendações -->
<Border Grid.Column="0" Margin="0,0,20,0"
BorderBrush="#bdc3c7" BorderThickness="1">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<TextBlock Text="Recomendações para Você"
FontSize="18" FontWeight="Bold"
Margin="20,20,20,10"/>
<ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto">
<ItemsControl ItemsSource="{Binding Recomendacoes}">
<ItemsControl.ItemTemplate>
<DataTemplate>
<Border Margin="10" Padding="15"
BorderBrush="#3498db"
BorderThickness="1"
CornerRadius="5"
Background="#ecf0f1">
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<StackPanel>
<TextBlock Text="{Binding ProdutoNome}"
FontSize="16" FontWeight="Bold"/>
<TextBlock Text="{Binding Categoria}"
Foreground="#7f8c8d"
Margin="0,5,0,0"/>
<TextBlock>
<Run Text="Score: "/>
<Run Text="{Binding Score, StringFormat=P2}"
Foreground="#27ae60"/>
<Run Text=" | "/>
<Run Text="{Binding Algoritmo}"
Foreground="#e74c3c"/>
</TextBlock>
</StackPanel>
<Button Grid.Column="1"
Content="Ver Detalhes"
Command="{Binding DataContext.ItemClicadoCommand,
RelativeSource={RelativeSource AncestorType=Window}}"
CommandParameter="{Binding}"
Padding="10,5"
Background="#3498db"
Foreground="White"/>
</Grid>
</Border>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</ScrollViewer>
</Grid>
</Border>
<!-- Informações do Usuário -->
<Border Grid.Column="1" BorderBrush="#bdc3c7"
BorderThickness="1" Padding="20">
<StackPanel>
<TextBlock Text="Seu Perfil" FontSize="16"
FontWeight="Bold" Margin="0,0,0,20"/>
<Image Width="100" Height="100"
Source="/Assets/avatar.png"
Margin="0,0,0,20"/>
<TextBlock Text="{Binding Usuario.Nome}"
FontSize="14" FontWeight="SemiBold"/>
<TextBlock Text="{Binding Usuario.Email}"
Foreground="#7f8c8d" Margin="0,5,0,0"/>
<TextBlock>
<Run Text="Idade: "/>
<Run Text="{Binding Usuario.Idade}"/>
</TextBlock>
<TextBlock Text="{Binding Usuario.Pais}"
Margin="0,5,0,0"/>
<Button Content="Atualizar Recomendações"
Command="{Binding CarregarRecomendacoesCommand}"
Margin="0,30,0,0" Padding="10"
Background="#2ecc71"
Foreground="White"/>
<ProgressBar Height="10" Margin="0,20,0,0"
IsIndeterminate="{Binding IsLoading}"
Visibility="{Binding IsLoading,
Converter={StaticResource BoolToVisibilityConverter}}"/>
</StackPanel>
</Border>
</Grid>
</Grid>
</Window>
```
---
## **5. ORQUESTRAÇÃO COM DOCKER COMPOSE**
### **docker-compose.yml:**
```yaml
version: '3.8'
services:
# Banco de Dados PostgreSQL
postgres:
image: postgres:15
container_name: sistema_ia_db
environment:
POSTGRES_DB: sistema_ia
POSTGRES_USER: postgres
POSTGRES_PASSWORD: senha123
ports:
- "5432:5432"
volumes:
- postgres_data:/var/lib/postgresql/data
- ./init.sql:/docker-entrypoint-initdb.d/init.sql
networks:
- ia-network
# Cache Redis
redis:
image: redis:7-alpine
container_name: sistema_ia_redis
ports:
- "6379:6379"
networks:
- ia-network
# Backend Java (Spring Boot)
backend-java:
build: ./backend-java
container_name: sistema_ia_backend
depends_on:
- postgres
- redis
ports:
- "8080:8080"
environment:
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/sistema_ia
SPRING_REDIS_HOST: redis
AI_SERVICE_URL: http://ia-python:5000
networks:
- ia-network
# Sistema de IA Python (FastAPI)
ia-python:
build: ./ia-python
container_name: sistema_ia_python
depends_on:
- postgres
- redis
ports:
- "5000:5000"
environment:
DATABASE_URL: postgresql://postgres:senha123@postgres:5432/sistema_ia
REDIS_URL: redis://redis:6379/0
volumes:
- ./ia-python/ml_models:/app/ml_models
networks:
- ia-network
# Frontend C# (expondo via API Gateway)
nginx:
image: nginx:alpine
container_name: sistema_ia_gateway
ports:
- "80:80"
- "443:443"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf
depends_on:
- backend-java
- ia-python
networks:
- ia-network
volumes:
postgres_data:
networks:
ia-network:
driver: bridge
```
### **nginx.conf:**
```nginx
events {
worker_connections 1024;
}
http {
upstream backend {
server backend-java:8080;
}
upstream ai_service {
server ia-python:5000;
}
server {
listen 80;
# API Gateway para backend Java
location /api/ {
proxy_pass http://backend;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
# CORS
add_header 'Access-Control-Allow-Origin' '*';
add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'Content-Type, Authorization';
}
# Roteamento para serviço de IA
location /ai/ {
rewrite ^/ai/(.*)$ /$1 break;
proxy_pass http://ai_service;
proxy_set_header Host $host;
}
# Health checks
location /health {
return 200 'healthy\n';
add_header Content-Type text/plain;
}
}
}
```
---
## **6. SCRIPT DE DEPLOY E INICIALIZAÇÃO**
### **setup.sh (Linux/Mac):**
```bash
#!/bin/bash
echo "🚀 Iniciando deploy do Sistema IA Multiplataforma"
# 1. Verificar Docker e Docker Compose
if ! command -v docker &> /dev/null; then
echo "❌ Docker não encontrado. Instale primeiro."
exit 1
fi
if ! command -v docker-compose &> /dev/null; then
echo "❌ Docker Compose não encontrado."
exit 1
fi
# 2. Criar diretórios necessários
mkdir -p ia-python/ml_models
mkdir -p backend-java/src/main/resources
mkdir -p nginx
# 3. Construir e iniciar containers
echo "📦 Construindo containers..."
docker-compose down
docker-compose build
docker-compose up -d
# 4. Aguardar serviços inicializarem
echo "⏳ Aguardando inicialização dos serviços..."
sleep 30
# 5. Verificar status
echo "🔍 Verificando status dos serviços..."
docker-compose ps
# 6. Inicializar banco de dados
echo "🗄️ Inicializando banco de dados..."
docker-compose exec postgres psql -U postgres -d sistema_ia -c "
CREATE TABLE IF NOT EXISTS teste (id SERIAL PRIMARY KEY, nome TEXT);
INSERT INTO teste (nome) VALUES ('Sistema IA Inicializado');
"
# 7. Treinar modelo inicial
echo "🧠 Treinando modelo de IA inicial..."
docker-compose exec ia-python python -c "
from services.ml_service import MLService
ml = MLService()
result = ml.train_model('collaborative')
print('Modelo treinado:', result)
"
# 8. Testar API
echo "🧪 Testando APIs..."
curl -f http://localhost:8080/api/health || echo "❌ Backend Java falhou"
curl -f http://localhost:5000/api/health || echo "❌ Serviço IA falhou"
echo "✅ Deploy concluído!"
echo "🌐 Acesse: http://localhost:80"
echo "🔧 Backend API: http://localhost:8080/api"
echo "🤖 IA Service: http://localhost:5000/api"
```
### **setup.ps1 (Windows):**
```powershell
# setup.ps1
Write-Host "🚀 Iniciando deploy do Sistema IA Multiplataforma" -ForegroundColor Green
# Verificar Docker
if (-not (Get-Command docker -ErrorAction SilentlyContinue)) {
Write-Host "❌ Docker não encontrado. Instale primeiro." -ForegroundColor Red
exit 1
}
# Parar containers existentes
docker-compose down
# Construir e iniciar
Write-Host "📦 Construindo containers..." -ForegroundColor Yellow
docker-compose build
docker-compose up -d
Start-Sleep -Seconds 30
Write-Host "✅ Sistema implantado com sucesso!" -ForegroundColor Green
Write-Host "🌐 Acesse: http://localhost" -ForegroundColor Cyan
```
---
## **7. MONITORAMENTO E LOGS**
### **Script de Monitoramento:**
```python
# monitor.py
import requests
import psycopg2
import redis
import json
from datetime import datetime
import schedule
import time
class SistemaIAMonitor:
def __init__(self):
self.services = {
'backend_java': 'http://localhost:8080/api/health',
'ia_python': 'http://localhost:5000/api/health',
'postgres': self.check_postgres,
'redis': self.check_redis
}
def check_postgres(self):
try:
conn = psycopg2.connect(
host="localhost",
database="sistema_ia",
user="postgres",
password="senha123"
)
conn.close()
return True
except:
return False
def check_redis(self):
try:
r = redis.Redis(host='localhost', port=6379)
return r.ping()
except:
return False
def monitor_all(self):
status = {}
for service_name, endpoint in self.services.items():
if callable(endpoint):
status[service_name] = endpoint()
else:
try:
response = requests.get(endpoint, timeout=5)
status[service_name] = response.status_code == 200
except:
status[service_name] = False
# Salvar log
self.log_status(status)
# Alertar se algum serviço falhou
failed = [name for name, is_up in status.items() if not is_up]
if failed:
self.send_alert(failed)
return status
def log_status(self, status):
log_entry = {
'timestamp': datetime.now().isoformat(),
'status': status
}
with open('monitor_log.json', 'a') as f:
f.write(json.dumps(log_entry) + '\n')
def send_alert(self, failed_services):
# Em produção, enviaria email/Slack
print(f"⚠️ ALERTA: Serviços falhando: {', '.join(failed_services)}")
# Executar monitoramento a cada 5 minutos
if __name__ == "__main__":
monitor = SistemaIAMonitor()
schedule.every(5).minutes.do(monitor.monitor_all)
print("🔍 Iniciando monitoramento do Sistema IA...")
while True:
schedule.run_pending()
time.sleep(1)
```
---
## **8. TESTES AUTOMATIZADOS**
### **Testes em Python:**
```python
# test_ia_service.py
import pytest
from fastapi.testclient import TestClient
from main import app
client = TestClient(app)
def test_recomendacoes_endpoint():
response = client.get("/api/recomendar/1")
assert response.status_code in [200, 404]
if response.status_code == 200:
data = response.json()
assert isinstance(data, list)
if data:
assert "produto_id" in data[0]
assert "score" in data[0]
def test_health_check():
response = client.get("/api/health")
assert response.status_code == 200
data = response.json()
assert data["status"] == "healthy"
```
### **Testes em Java:**
```java
// RecomendacaoServiceTest.java
@SpringBootTest
class RecomendacaoServiceTest {
@Autowired
private RecomendacaoService recomendacaoService;
@MockBean
private RecomendacaoRepository recomendacaoRepository;
@Test
void testGetRecomendacoesUsuarioExistente() {
// Mock setup
when(recomendacaoRepository.findByUsuarioIdAndExibidaFalse(anyLong()))
.thenReturn(Collections.emptyList());
// Test
List<RecomendacaoDTO> recomendacoes =
recomendacaoService.getRecomendacoes(1L);
assertNotNull(recomendacoes);
}
}
```
### **Testes em C#:**
```csharp
[TestClass]
public class ApiServiceTests
{
[TestMethod]
public async Task GetRecomendacoesAsync_ReturnsRecomendacoes()
{
// Arrange
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("http://localhost:8080/api/recomendacoes/usuario/1")
.Respond("application/json",
"[{\"produtoId\":1,\"produtoNome\":\"Teste\"}]");
var httpClient = new HttpClient(mockHttp);
var apiService = new ApiService(httpClient);
// Act
var recomendacoes = await apiService.GetRecomendacoesAsync(1);
// Assert
Assert.IsNotNull(recomendacoes);
Assert.AreEqual(1, recomendacoes.Count);
}
}
```
---
## **🎯 RESUMO DA ARQUITETURA**
### **Fluxo de Dados:**
1. **Usuário** interage com aplicação C#
2. **C#** chama API REST do backend Java
3. **Java** consulta cache Redis, se não encontrar:
4. **Java** chama serviço Python de IA
5. **Python** processa algoritmos ML e retorna recomendações
6. **Java** salva no PostgreSQL e cache Redis
7. **Resposta** retorna ao usuário via C#
### **Vantagens desta Arquitetura:**
- ✅ **Separação de responsabilidades**
- ✅ **Escalabilidade horizontal**
- ✅ **Polyglot persistence** (PostgreSQL + Redis)
- ✅ **Cache distribuído**
- ✅ **Fácil manutenção e deploy**
- ✅ **Resiliência a falhas**
### **Próximos Passos para Produção:**
1. **Autenticação JWT** entre serviços
2. **API Gateway** (Kong/Traefik)
3. **Message Queue** (RabbitMQ/Kafka) para processamento assíncrono
4. **Kubernetes** para orquestração
5. **ELK Stack** para logs
6. **Prometheus + Grafana** para monitoramento
7. **CI/CD** pipeline (GitLab CI/Jenkins)
---
## **🚀 COMEÇAR A USAR**
### **Passo a Passo:**
```bash
# 1. Clone o repositório
git clone https://github.com/seu-usuario/sistema-ia.git
cd sistema-ia
# 2. Execute o setup (Linux/Mac)
chmod +x setup.sh
./setup.sh
# Windows
# .\setup.ps1
# 3. Acesse o sistema:
# Frontend: http://localhost
# Backend API: http://localhost:8080/swagger-ui.html
# IA Service: http://localhost:5000/docs
# 4. Teste com usuário ID 1:
curl http://localhost:8080/api/recomendacoes/usuario/1
```
Este sistema completo demonstra como integrar **C# (frontend)**, **Java (backend)**, **Python (IA)**, **PostgreSQL (banco)** e **Redis (cache)** em uma arquitetura moderna e escalável para sistemas inteligentes! 🚀
