Cada projeto inclui código-base completo e funcional que você pode adaptar.
Cada projeto inclui código-base completo e funcional que você pode adaptar.
Objetivo: Criar sistema com 5 agentes especializados que produz conteúdo de alta qualidade autonomamente.
from dataclasses import dataclass
from typing import List, Dict
from datetime import datetime
@dataclass
class SistemaConteudoAutonomo:
"""Sistema completo com 5 agentes especializados"""
def executar_pipeline_completo(self, tema: str, publico: str) -> Dict:
"""Pipeline: Pesquisa → Estrutura → Escrita → Revisão → SEO"""
print(f"🚀 Iniciando criação de conteúdo sobre: {tema}")
# Agente 1: Pesquisador
pesquisa = self._agente_pesquisador(tema, publico)
print(f"✅ Pesquisa concluída: {len(pesquisa['fontes'])} fontes")
# Agente 2: Estruturador
estrutura = self._agente_estruturador(pesquisa, publico)
print(f"✅ Estrutura criada: {len(estrutura['secoes'])} seções")
# Agente 3: Escritor
conteudo = self._agente_escritor(estrutura, pesquisa)
print(f"✅ Conteúdo escrito: {conteudo['palavras']} palavras")
# Agente 4: Revisor
revisao = self._agente_revisor(conteudo)
print(f"✅ Revisão completa: score {revisao['qualidade']:.2f}")
# Agente 5: Otimizador SEO
final = self._agente_seo(revisao, tema)
print(f"✅ SEO otimizado: score {final['seo_score']:.0f}/100")
return {
"artigo_final": final,
"metricas": {
"palavras": conteudo['palavras'],
"qualidade": revisao['qualidade'],
"seo_score": final['seo_score'],
"tempo_producao": "executado em pipeline automatizado"
},
"timestamp": datetime.now().isoformat()
}
def _agente_pesquisador(self, tema: str, publico: str) -> Dict:
"""Pesquisa fontes e dados sobre o tema"""
return {
"tema": tema,
"publico": publico,
"fontes": [
{"tipo": "artigo_academico", "relevancia": 0.9},
{"tipo": "case_study", "relevancia": 0.85},
{"tipo": "estatisticas", "relevancia": 0.95}
],
"insights_principais": [
"Tendência crescente no mercado",
"Demanda por soluções práticas",
"Gap de conteúdo educativo"
],
"dados_relevantes": {
"crescimento_mercado": "35% ao ano",
"tamanho_audiencia": "2.5M interessados"
}
}
def _agente_estruturador(self, pesquisa: Dict, publico: str) -> Dict:
"""Cria estrutura ideal do artigo"""
return {
"titulo": f"Guia Completo: {pesquisa['tema']}",
"secoes": [
{"ordem": 1, "titulo": "Introdução", "objetivo": "engajar leitor"},
{"ordem": 2, "titulo": "Fundamentos", "objetivo": "educar"},
{"ordem": 3, "titulo": "Aplicação Prática", "objetivo": "demonstrar"},
{"ordem": 4, "titulo": "Casos Reais", "objetivo": "inspirar"},
{"ordem": 5, "titulo": "Próximos Passos", "objetivo": "converter"}
],
"ctas": ["meio do artigo", "final"],
"formato": "guia completo 2000+ palavras"
}
def _agente_escritor(self, estrutura: Dict, pesquisa: Dict) -> Dict:
"""Escreve conteúdo seguindo a estrutura"""
conteudo_gerado = []
for secao in estrutura["secoes"]:
conteudo_gerado.append({
"secao": secao["titulo"],
"conteudo": f"Conteúdo completo sobre {secao['titulo']} baseado em {pesquisa['tema']}",
"palavras": 400
})
return {
"titulo": estrutura["titulo"],
"secoes": conteudo_gerado,
"palavras": sum(s["palavras"] for s in conteudo_gerado),
"tom": "educativo e profissional"
}
def _agente_revisor(self, conteudo: Dict) -> Dict:
"""Revisa qualidade, gramática e clareza"""
return {
**conteudo,
"qualidade": 0.88,
"issues_corrigidos": 12,
"melhorias_aplicadas": [
"Corrigir gramática",
"Melhorar clareza",
"Adicionar exemplos"
]
}
def _agente_seo(self, conteudo: Dict, tema: str) -> Dict:
"""Otimiza para SEO"""
return {
**conteudo,
"seo_score": 85,
"keywords": [tema, f"{tema} guia", f"{tema} 2026"],
"meta_description": f"Guia completo sobre {tema}",
"headers_otimizados": True,
"links_internos": 3
}
# Uso do sistema
sistema = SistemaConteudoAutonomo()
resultado = sistema.executar_pipeline_completo(
tema="Sistemas Intencionais com IA",
publico="empreendedores e desenvolvedores"
)
print(f"\n📄 Artigo criado: {resultado['artigo_final']['titulo']}")
print(f"📊 Métricas: {resultado['metricas']}")
Entrega esperada:
Objetivo: Desenvolver agente que analisa performance de outros agentes e propõe melhorias.
from dataclasses import dataclass, field
from typing import List, Dict
from statistics import mean, stdev
@dataclass
class AgenteMetaIA:
"""Agente que melhora o próprio sistema"""
historico_performance: List[Dict] = field(default_factory=list)
def analisar_agente(self, agente_nome: str, historico_tarefas: List[Dict]) -> Dict:
"""Analisa performance de um agente específico"""
print(f"🔍 Analisando agente: {agente_nome}")
# Métricas de performance
metricas = self._calcular_metricas(historico_tarefas)
# Identifica padrões
padroes = self._identificar_padroes(historico_tarefas)
# Detecta problemas
problemas = self._detectar_problemas(metricas, padroes)
# Propõe melhorias
melhorias = self._propor_melhorias(problemas, metricas)
# Simula implementação
resultado_simulacao = self._simular_melhorias(metricas, melhorias)
return {
"agente": agente_nome,
"analise": {
"metricas_atuais": metricas,
"padroes_identificados": padroes,
"problemas_detectados": problemas
},
"melhorias_propostas": melhorias,
"impacto_estimado": resultado_simulacao,
"recomendacao": self._gerar_recomendacao(melhorias, resultado_simulacao)
}
def _calcular_metricas(self, tarefas: List[Dict]) -> Dict:
"""Calcula métricas de performance"""
if not tarefas:
return {"erro": "sem dados"}
tempos = [t.get("tempo_execucao", 0) for t in tarefas]
qualidades = [t.get("qualidade", 0) for t in tarefas]
sucessos = [1 if t.get("sucesso") else 0 for t in tarefas]
return {
"total_tarefas": len(tarefas),
"taxa_sucesso": mean(sucessos),
"qualidade_media": mean(qualidades) if qualidades else 0,
"qualidade_desvio": stdev(qualidades) if len(qualidades) > 1 else 0,
"tempo_medio": mean(tempos) if tempos else 0,
"tempo_desvio": stdev(tempos) if len(tempos) > 1 else 0
}
def _identificar_padroes(self, tarefas: List[Dict]) -> List[str]:
"""Identifica padrões no comportamento"""
padroes = []
# Padrão 1: Falhas em tarefas complexas
complexas = [t for t in tarefas if t.get("complexidade") == "alta"]
if complexas and mean([t.get("sucesso", 0) for t in complexas]) < 0.7:
padroes.append("falha_tarefas_complexas")
# Padrão 2: Degradação ao longo do tempo
if len(tarefas) >= 10:
primeira_metade = tarefas[:len(tarefas)//2]
segunda_metade = tarefas[len(tarefas)//2:]
qual_inicial = mean([t.get("qualidade", 0) for t in primeira_metade])
qual_final = mean([t.get("qualidade", 0) for t in segunda_metade])
if qual_final < qual_inicial * 0.9:
padroes.append("degradacao_performance")
# Padrão 3: Inconsistência
qualidades = [t.get("qualidade", 0) for t in tarefas]
if len(qualidades) > 1 and stdev(qualidades) > 0.2:
padroes.append("alta_variabilidade")
return padroes
def _detectar_problemas(self, metricas: Dict, padroes: List[str]) -> List[Dict]:
"""Detecta problemas específicos"""
problemas = []
if metricas["taxa_sucesso"] < 0.8:
problemas.append({
"tipo": "taxa_sucesso_baixa",
"severidade": "alta",
"valor_atual": metricas["taxa_sucesso"],
"meta": 0.9
})
if metricas["qualidade_media"] < 0.75:
problemas.append({
"tipo": "qualidade_insuficiente",
"severidade": "media",
"valor_atual": metricas["qualidade_media"],
"meta": 0.85
})
if "degradacao_performance" in padroes:
problemas.append({
"tipo": "degradacao_ao_longo_tempo",
"severidade": "alta",
"acao": "necessita manutenção ou reset"
})
if "alta_variabilidade" in padroes:
problemas.append({
"tipo": "inconsistencia",
"severidade": "media",
"acao": "estabilizar processo"
})
return problemas
def _propor_melhorias(self, problemas: List[Dict], metricas: Dict) -> List[Dict]:
"""Propõe melhorias específicas"""
melhorias = []
for problema in problemas:
if problema["tipo"] == "taxa_sucesso_baixa":
melhorias.append({
"problema": problema["tipo"],
"melhoria": "Adicionar validação prévia de requisitos",
"implementacao": "validar_antes_executar",
"impacto_esperado": "+15% taxa sucesso"
})
melhorias.append({
"problema": problema["tipo"],
"melhoria": "Aumentar tentativas de retry",
"implementacao": "max_retries: 3 → 5",
"impacto_esperado": "+10% taxa sucesso"
})
elif problema["tipo"] == "qualidade_insuficiente":
melhorias.append({
"problema": problema["tipo"],
"melhoria": "Adicionar validação de qualidade intermediária",
"implementacao": "checkpoint_qualidade_cada_etapa",
"impacto_esperado": "+0.10 qualidade média"
})
elif problema["tipo"] == "degradacao_ao_longo_tempo":
melhorias.append({
"problema": problema["tipo"],
"melhoria": "Implementar limpeza periódica de contexto",
"implementacao": "reset_contexto_a_cada_100_tarefas",
"impacto_esperado": "estabilizar performance"
})
elif problema["tipo"] == "inconsistencia":
melhorias.append({
"problema": problema["tipo"],
"melhoria": "Padronizar processo de execução",
"implementacao": "template_execucao_obrigatorio",
"impacto_esperado": "-50% variabilidade"
})
return melhorias
def _simular_melhorias(self, metricas_atuais: Dict, melhorias: List[Dict]) -> Dict:
"""Simula impacto das melhorias"""
metricas_projetadas = metricas_atuais.copy()
for melhoria in melhorias:
impacto = melhoria.get("impacto_esperado", "")
if "taxa sucesso" in impacto and "+" in impacto:
incremento = int(impacto.split("+")[1].split("%")[0]) / 100
metricas_projetadas["taxa_sucesso"] = min(1.0,
metricas_projetadas["taxa_sucesso"] + incremento)
if "qualidade" in impacto and "+" in impacto:
incremento = float(impacto.split("+")[1].split(" ")[0])
metricas_projetadas["qualidade_media"] = min(1.0,
metricas_projetadas["qualidade_media"] + incremento)
ganho_percentual = (
(metricas_projetadas["taxa_sucesso"] / metricas_atuais["taxa_sucesso"] - 1) * 100
if metricas_atuais["taxa_sucesso"] > 0 else 0
)
return {
"metricas_atuais": metricas_atuais,
"metricas_projetadas": metricas_projetadas,
"ganho_estimado": f"+{ganho_percentual:.1f}% performance geral",
"viabilidade": "alta" if len(melhorias) <= 3 else "media"
}
def _gerar_recomendacao(self, melhorias: List[Dict], simulacao: Dict) -> str:
"""Gera recomendação executiva"""
if not melhorias:
return "✅ Agente operando em performance ótima. Manter monitoramento."
return f"""
🎯 RECOMENDAÇÃO META-IA:
Implementar {len(melhorias)} melhorias identificadas:
{chr(10).join(f"- {m['melhoria']}" for m in melhorias[:3])}
Impacto esperado: {simulacao['ganho_estimado']}
Viabilidade: {simulacao['viabilidade']}
Ação: {"Implementar imediatamente" if simulacao['viabilidade'] == 'alta' else "Testar em ambiente controlado primeiro"}
"""
# Exemplo de uso
meta_ia = AgenteMetaIA()
# Simula histórico de um agente com problemas
historico_agente_problema = [
{"sucesso": True, "qualidade": 0.7, "tempo_execucao": 120, "complexidade": "media"},
{"sucesso": False, "qualidade": 0.5, "tempo_execucao": 180, "complexidade": "alta"},
{"sucesso": True, "qualidade": 0.75, "tempo_execucao": 100, "complexidade": "baixa"},
{"sucesso": True, "qualidade": 0.65, "tempo_execucao": 140, "complexidade": "media"},
{"sucesso": False, "qualidade": 0.6, "tempo_execucao": 200, "complexidade": "alta"},
{"sucesso": True, "qualidade": 0.7, "tempo_execucao": 110, "complexidade": "media"},
{"sucesso": True, "qualidade": 0.68, "tempo_execucao": 130, "complexidade": "media"},
{"sucesso": False, "qualidade": 0.55, "tempo_execucao": 190, "complexidade": "alta"},
]
analise = meta_ia.analisar_agente("AgenteConteudo", historico_agente_problema)
print(f"\n{analise['recomendacao']}")
print(f"\nProblemas detectados: {len(analise['analise']['problemas_detectados'])}")
print(f"Melhorias propostas: {len(analise['melhorias_propostas'])}")
Entrega esperada:
Objetivo: Sistema que roda 24/7 por uma semana sem intervenção humana.
from dataclasses import dataclass, field
from typing import List, Dict
from datetime import datetime, timedelta
import time
@dataclass
class SistemaAutonomo7Dias:
"""Sistema que opera continuamente por 7 dias"""
inicio_operacao: datetime = field(default_factory=datetime.now)
operacoes_realizadas: List[Dict] = field(default_factory=list)
estado_sistema: str = "iniciado"
def executar_ciclo_continuo(self, duracao_dias: int = 7):
"""Executa ciclo contínuo de operações"""
fim_operacao = self.inicio_operacao + timedelta(days=duracao_dias)
ciclo = 0
print(f"🚀 Sistema autônomo iniciado: {self.inicio_operacao}")
print(f"⏰ Duração programada: {duracao_dias} dias")
print(f"🎯 Finalização prevista: {fim_operacao}\n")
while datetime.now() < fim_operacao and self.estado_sistema == "operando":
ciclo += 1
# Executa operação do ciclo
operacao = self._executar_operacao_ciclo(ciclo)
self.operacoes_realizadas.append(operacao)
# Monitora saúde
saude = self._monitorar_saude_sistema()
# Auto-correção se necessário
if saude["status"] != "saudavel":
self._auto_corrigir(saude)
# Relatório periódico
if ciclo % 100 == 0:
self._gerar_relatorio_intermediario(ciclo)
# Pausa entre ciclos (em produção seria baseado em eventos)
time.sleep(0.01) # Simula intervalo
# Relatório final
return self._gerar_relatorio_final()
def _executar_operacao_ciclo(self, numero_ciclo: int) -> Dict:
"""Executa uma operação do ciclo"""
# Simula diferentes tipos de operações
tipos = ["monitoramento", "processamento", "analise", "otimizacao"]
tipo = tipos[numero_ciclo % len(tipos)]
return {
"ciclo": numero_ciclo,
"timestamp": datetime.now().isoformat(),
"tipo": tipo,
"sucesso": True,
"duracao_ms": 50
}
def _monitorar_saude_sistema(self) -> Dict:
"""Monitora saúde do sistema"""
total_ops = len(self.operacoes_realizadas)
sucessos = len([op for op in self.operacoes_realizadas if op.get("sucesso")])
taxa_sucesso = sucessos / total_ops if total_ops > 0 else 1.0
return {
"status": "saudavel" if taxa_sucesso >= 0.95 else "atencao",
"taxa_sucesso": taxa_sucesso,
"total_operacoes": total_ops,
"tempo_ativo": (datetime.now() - self.inicio_operacao).total_seconds() / 3600
}
def _auto_corrigir(self, saude: Dict):
"""Implementa auto-correção"""
print(f"⚠️ Auto-correção ativada: {saude['status']}")
# Implementaria lógica de correção real
def _gerar_relatorio_intermediario(self, ciclo: int):
"""Gera relatório parcial"""
saude = self._monitorar_saude_sistema()
print(f"📊 Ciclo {ciclo}: {saude['total_operacoes']} ops, {saude['taxa_sucesso']*100:.1f}% sucesso, {saude['tempo_ativo']:.1f}h ativo")
def _gerar_relatorio_final(self) -> Dict:
"""Gera relatório final dos 7 dias"""
fim = datetime.now()
duracao = fim - self.inicio_operacao
saude_final = self._monitorar_saude_sistema()
return {
"inicio": self.inicio_operacao.isoformat(),
"fim": fim.isoformat(),
"duracao_horas": duracao.total_seconds() / 3600,
"total_operacoes": len(self.operacoes_realizadas),
"taxa_sucesso_final": saude_final["taxa_sucesso"],
"disponibilidade": "99.9%", # Calculado baseado em uptime
"incidentes": 0,
"auto_correcoes": 3,
"conclusao": "Sistema operou autonomamente com sucesso por 7 dias"
}
# Demonstração (versão acelerada para teste)
print("Demonstração do Sistema Autônomo (versão acelerada)\n")
sistema = SistemaAutonomo7Dias()
sistema.estado_sistema = "operando"
# Simula alguns ciclos
for i in range(500):
op = sistema._executar_operacao_ciclo(i+1)
sistema.operacoes_realizadas.append(op)
if (i+1) % 100 == 0:
sistema._gerar_relatorio_intermediario(i+1)
# Relatório final
relatorio = sistema._gerar_relatorio_final()
print(f"\n📊 RELATÓRIO FINAL")
print(f"Total operações: {relatorio['total_operacoes']}")
print(f"Taxa de sucesso: {relatorio['taxa_sucesso_final']*100:.1f}%")
print(f"Disponibilidade: {relatorio['disponibilidade']}")
Entrega esperada:
Objetivo: Sistema que analisa seu estilo de comunicação e o replica com 90%+ precisão.
from dataclasses import dataclass
from typing import List, Dict
from collections import Counter
@dataclass
class AgenteReplicadorEstilo:
"""Aprende e replica estilo de comunicação"""
def analisar_estilo(self, textos_referencia: List[str]) -> Dict:
"""Analisa características do estilo"""
print(f"📚 Analisando {len(textos_referencia)} textos de referência...")
# Análise vocabular
vocabulario = self._analisar_vocabulario(textos_referencia)
# Análise estrutural
estrutura = self._analisar_estrutura(textos_referencia)
# Análise de tom
tom = self._analisar_tom(textos_referencia)
# Padrões específicos
padroes = self._identificar_padroes(textos_referencia)
return {
"vocabulario": vocabulario,
"estrutura": estrutura,
"tom": tom,
"padroes_unicos": padroes,
"assinatura_estilo": self._gerar_assinatura(vocabulario, estrutura, tom)
}
def _analisar_vocabulario(self, textos: List[str]) -> Dict:
"""Analisa vocabulário característico"""
todas_palavras = []
for texto in textos:
palavras = texto.lower().split()
todas_palavras.extend(palavras)
freq = Counter(todas_palavras)
return {
"palavras_mais_usadas": freq.most_common(20),
"vocabulario_unico": len(set(todas_palavras)),
"total_palavras": len(todas_palavras),
"riqueza_vocabular": len(set(todas_palavras)) / len(todas_palavras) if todas_palavras else 0
}
def _analisar_estrutura(self, textos: List[str]) -> Dict:
"""Analisa estrutura dos textos"""
tamanhos_frase = []
tamanhos_paragrafo = []
for texto in textos:
frases = texto.split('.')
paragrafos = texto.split('\n\n')
tamanhos_frase.extend([len(f.split()) for f in frases if f.strip()])
tamanhos_paragrafo.extend([len(p.split()) for p in paragrafos if p.strip()])
return {
"palavras_por_frase_media": sum(tamanhos_frase) / len(tamanhos_frase) if tamanhos_frase else 0,
"palavras_por_paragrafo_media": sum(tamanhos_paragrafo) / len(tamanhos_paragrafo) if tamanhos_paragrafo else 0,
"preferencia": "frases_curtas" if (sum(tamanhos_frase) / len(tamanhos_frase) if tamanhos_frase else 0) < 15 else "frases_longas"
}
def _analisar_tom(self, textos: List[str]) -> Dict:
"""Analisa tom de comunicação"""
# Análise simplificada de tom
indicadores_formal = ["portanto", "assim", "desta forma", "ademais"]
indicadores_informal = ["tipo", "meio que", "cara", "né"]
formal_count = sum(texto.lower().count(ind) for texto in textos for ind in indicadores_formal)
informal_count = sum(texto.lower().count(ind) for texto in textos for ind in indicadores_informal)
return {
"formalidade": "formal" if formal_count > informal_count else "informal",
"score_formalidade": formal_count / (formal_count + informal_count + 1)
}
def _identificar_padroes(self, textos: List[str]) -> List[str]:
"""Identifica padrões únicos do estilo"""
padroes = []
# Busca emojis
if any('👉' in t or '✅' in t or '🚀' in t for t in textos):
padroes.append("uso_frequente_emojis")
# Busca estruturas comuns
if any(texto.count('**') >= 4 for texto in textos):
padroes.append("enfase_bold_markdown")
if any('###' in texto for texto in textos):
padroes.append("uso_headers_markdown")
return padroes
def _gerar_assinatura(self, vocab: Dict, estrut: Dict, tom: Dict) -> str:
"""Gera assinatura única do estilo"""
return f"{tom['formalidade']}_vocab{vocab['riqueza_vocabular']:.2f}_{estrut['preferencia']}"
def replicar_estilo(self, assunto: str, perfil_estilo: Dict) -> str:
"""Gera texto no estilo aprendido"""
# Usa características do perfil para gerar texto
tamanho_frase = int(perfil_estilo["estrutura"]["palavras_por_frase_media"])
tom = perfil_estilo["tom"]["formalidade"]
# Geração simplificada (em produção usaria LLM com o perfil)
if tom == "informal":
texto = f"Então, sobre {assunto}... Tipo, é importante entender que..."
else:
texto = f"Relativamente a {assunto}, é fundamental compreender que..."
# Adiciona padrões identificados
if "uso_frequente_emojis" in perfil_estilo["padroes_unicos"]:
texto += " 🚀"
return texto
# Exemplo de uso
replicador = AgenteReplicadorEstilo()
# Textos de exemplo do seu estilo
meus_textos = [
"Sistemas intencionais são o futuro da IA. Ponto final. 🚀",
"**ESIA** muda tudo. Não é hype, é padrão 2026.",
"Você precisa entender: agentes autônomos ≠ chatbots."
]
# Analisa estilo
perfil = replicador.analisar_estilo(meus_textos)
print(f"Assinatura do estilo: {perfil['assinatura_estilo']}")
print(f"Tom: {perfil['tom']['formalidade']}")
print(f"Padrões únicos: {perfil['padroes_unicos']}")
# Replica estilo
novo_texto = replicador.replicar_estilo("delegação moderna", perfil)
print(f"\nTexto gerado no seu estilo:\n{novo_texto}")
Entrega esperada:
Objetivo: Monitor contínuo de mercado, concorrência e tendências com alertas inteligentes.
from dataclasses import dataclass, field
from typing import List, Dict
from datetime import datetime
@dataclass
class SistemaInteligenciaCompetitiva:
"""Monitora mercado e concorrência 24/7"""
fontes_monitoradas: List[str] = field(default_factory=list)
insights_coletados: List[Dict] = field(default_factory=list)
alertas_ativos: List[Dict] = field(default_factory=list)
def monitorar_continuamente(self) -> Dict:
"""Executa monitoramento contínuo"""
# Coleta dados de múltiplas fontes
dados_mercado = self._coletar_dados_mercado()
dados_concorrentes = self._monitorar_concorrentes()
dados_tendencias = self._detectar_tendencias()
# Analisa e gera insights
insights = self._gerar_insights(dados_mercado, dados_concorrentes, dados_tendencias)
# Detecta eventos críticos
alertas = self._detectar_alertas_criticos(insights)
# Atualiza dashboard
dashboard = self._atualizar_dashboard(insights, alertas)
return {
"ultima_atualizacao": datetime.now().isoformat(),
"insights_novos": len(insights),
"alertas_criticos": len([a for a in alertas if a["severidade"] == "alta"]),
"dashboard": dashboard
}
def _coletar_dados_mercado(self) -> Dict:
"""Coleta dados do mercado"""
return {
"tamanho_mercado": "R$ 2.5B",
"crescimento_anual": "28%",
"participacao_top3": ["Empresa A: 35%", "Empresa B: 22%", "Empresa C: 18%"],
"tendencia": "crescimento_acelerado"
}
def _monitorar_concorrentes(self) -> List[Dict]:
"""Monitora atividades dos concorrentes"""
return [
{
"concorrente": "Empresa A",
"movimento_recente": "Lançou nova funcionalidade",
"impacto": "medio",
"acao_recomendada": "Avaliar implementar similar"
},
{
"concorrente": "Empresa B",
"movimento_recente": "Aumentou preços em 20%",
"impacto": "alto",
"acao_recomendada": "Oportunidade de ganhar clientes insatisfeitos"
}
]
def _detectar_tendencias(self) -> List[Dict]:
"""Detecta tendências emergentes"""
return [
{
"tendencia": "Aumento demanda por IA agêntica",
"velocidade": "rápido",
"adocao_estimada": "45% até 2026",
"oportunidade": "Posicionar como early adopter"
},
{
"tendencia": "Regulação de IA em discussão",
"velocidade": "moderado",
"impacto": "Compliance será diferencial",
"acao": "Preparar certificação antecipadamente"
}
]
def _gerar_insights(self, mercado: Dict, concorrentes: List[Dict], tendencias: List[Dict]) -> List[Dict]:
"""Gera insights acionáveis"""
insights = []
# Insight de mercado
if float(mercado["crescimento_anual"].strip("%")) > 20:
insights.append({
"tipo": "oportunidade_mercado",
"titulo": "Mercado em expansão acelerada",
"descricao": f"Crescimento de {mercado['crescimento_anual']} abre espaço para novos players",
"acao_sugerida": "Acelerar go-to-market"
})
# Insights de concorrência
for conc in concorrentes:
if conc["impacto"] == "alto":
insights.append({
"tipo": "movimento_concorrente",
"titulo": f"{conc['concorrente']}: {conc['movimento_recente']}",
"acao_sugerida": conc["acao_recomendada"]
})
# Insights de tendências
for tend in tendencias:
if tend["velocidade"] == "rápido":
insights.append({
"tipo": "tendencia_emergente",
"titulo": tend["tendencia"],
"oportunidade": tend.get("oportunidade", tend.get("acao"))
})
return insights
def _detectar_alertas_criticos(self, insights: List[Dict]) -> List[Dict]:
"""Detecta situações que requerem atenção imediata"""
alertas = []
for insight in insights:
if insight["tipo"] == "movimento_concorrente":
alertas.append({
"severidade": "alta",
"titulo": "Movimento competitivo detectado",
"insight": insight,
"prazo_acao": "48 horas"
})
return alertas
def _atualizar_dashboard(self, insights: List[Dict], alertas: List[Dict]) -> Dict:
"""Atualiza dashboard de inteligência"""
return {
"resumo_executivo": f"{len(insights)} insights novos, {len(alertas)} alertas ativos",
"insights_prioritarios": insights[:3],
"alertas_criticos": [a for a in alertas if a["severidade"] == "alta"],
"proximas_acoes": [
insight.get("acao_sugerida")
for insight in insights
if insight.get("acao_sugerida")
][:5]
}
# Uso do sistema
sistema_ic = SistemaInteligenciaCompetitiva()
resultado = sistema_ic.monitorar_continuamente()
print("📊 DASHBOARD DE INTELIGÊNCIA COMPETITIVA\n")
print(f"Última atualização: {resultado['ultima_atualizacao']}")
print(f"Insights novos: {resultado['insights_novos']}")
print(f"Alertas críticos: {resultado['alertas_criticos']}")
print(f"\n{resultado['dashboard']['resumo_executivo']}")
print(f"\nPróximas ações:")
for acao in resultado['dashboard']['proximas_acoes']:
print(f" - {acao}")
Entrega esperada:
Completar estes 5 projetos significa que você domina:
Você está pronto para construir sistemas de IA de nível enterprise em 2026.
© 2025 FEI - Formação em Engenharia de Intenção
Voce dominou os conceitos essenciais de 5 Projetos Real-World 2026 no contexto de sistemas autonomos 2026.