Portfólio de IA: 7 Projetos que Impressionam Recrutadores

Um portfólio forte vale mais que qualquer certificado. Recrutadores querem ver código real, funcionando, deployado. Aqui estão 7 projetos que vão te destacar no mercado de IA.

O que Faz um Bom Projeto de Portfólio

• Resolve um problema real — não só tutoriais copiados
• Está deployado — recrutador pode testar
• Tem README completo — explica o que faz e como rodar
• Código limpo — bem organizado, com comentários
• Demonstra suas skills — LLMs, RAG, agentes, etc.

Projeto 1: Chatbot com RAG sobre Documentos

Dificuldade: ⭐⭐ Intermediário
Tempo: 1-2 semanas
Por que impressiona: RAG é a skill mais pedida em vagas de IA

O que construir

Um chatbot que responde perguntas sobre PDFs ou documentos que o usuário faz upload.

# Estrutura do projeto
rag-chatbot/
├── app.py              # Interface Streamlit
├── rag/
│   ├── loader.py       # Carrega e processa PDFs
│   ├── vectorstore.py  # Gerencia embeddings
│   └── chain.py        # Chain de Q&A
├── requirements.txt
├── Dockerfile
└── README.md

Código principal

# rag/chain.py
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate

PROMPT_TEMPLATE = """
Use o contexto abaixo para responder a pergunta.
Se não souber a resposta, diga "Não encontrei essa informação nos documentos."

Contexto:
{context}

Pergunta: {question}

Resposta:"""

def create_qa_chain(vectorstore):
    llm = ChatOpenAI(model="gpt-4", temperature=0)
    
    prompt = PromptTemplate(
        template=PROMPT_TEMPLATE,
        input_variables=["context", "question"]
    )
    
    chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
        chain_type_kwargs={"prompt": prompt}
    )
    
    return chain

Projeto 2: Agente de IA com Ferramentas

Dificuldade: ⭐⭐⭐ Avançado
Tempo: 2-3 semanas
Por que impressiona: Mostra que você sabe construir sistemas autônomos

O que construir

Um assistente que pode executar ações como buscar clima, criar eventos, enviar emails.

# Definindo ferramentas para o agente
from openai import OpenAI

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Busca previsão do tempo para uma cidade",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nome da cidade"},
                    "days": {"type": "integer", "description": "Dias de previsão"}
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Busca informações na web",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Termo de busca"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "create_reminder",
            "description": "Cria um lembrete",
            "parameters": {
                "type": "object",
                "properties": {
                    "message": {"type": "string"},
                    "datetime": {"type": "string", "description": "ISO format"}
                },
                "required": ["message", "datetime"]
            }
        }
    }
]

# Loop do agente
def run_agent(user_message):
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = client.chat.completions.create(
            model="gpt-4",
            messages=messages,
            tools=tools
        )
        
        if response.choices[0].finish_reason == "tool_calls":
            # Executar ferramentas e continuar
            tool_calls = response.choices[0].message.tool_calls
            for tool_call in tool_calls:
                result = execute_tool(tool_call)
                messages.append({"role": "tool", "content": result})
        else:
            # Resposta final
            return response.choices[0].message.content

Projeto 3: API de Sumarização Inteligente

Dificuldade: ⭐⭐ Intermediário
Tempo: 1 semana
Por que impressiona: API bem estruturada mostra maturidade como dev

# main.py - FastAPI
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from openai import OpenAI
import redis

app = FastAPI()
client = OpenAI()
cache = redis.Redis(host='localhost', port=6379)

class SummarizeRequest(BaseModel):
    text: str
    max_length: int = 200
    style: str = "professional"  # professional, casual, bullet_points

class SummarizeResponse(BaseModel):
    summary: str
    original_length: int
    summary_length: int

@app.post("/summarize", response_model=SummarizeResponse)
async def summarize(request: SummarizeRequest):
    # Check cache
    cache_key = f"summary:{hash(request.text)}"
    cached = cache.get(cache_key)
    if cached:
        return SummarizeResponse.parse_raw(cached)
    
    # Generate summary
    prompt = f"""
    Resuma o texto abaixo em no máximo {request.max_length} palavras.
    Estilo: {request.style}
    
    Texto:
    {request.text}
    """
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3
    )
    
    summary = response.choices[0].message.content
    
    result = SummarizeResponse(
        summary=summary,
        original_length=len(request.text.split()),
        summary_length=len(summary.split())
    )
    
    # Cache result
    cache.setex(cache_key, 3600, result.json())
    
    return result

Projeto 4: Classificador de Intenções para Chatbot

Dificuldade: ⭐⭐ Intermediário
Tempo: 1 semana
Por que impressiona: Útil para qualquer sistema de atendimento

# intent_classifier.py
from openai import OpenAI

INTENTS = {
    "billing": "Questões sobre pagamento, faturas, cobranças",
    "technical_support": "Problemas técnicos, bugs, erros",
    "sales": "Interesse em comprar, upgrade, planos",
    "cancellation": "Cancelar serviço ou assinatura",
    "general": "Dúvidas gerais, outras questões"
}

def classify_intent(message: str) -> dict:
    client = OpenAI()
    
    intent_descriptions = "\n".join(
        f"- {k}: {v}" for k, v in INTENTS.items()
    )
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "system",
                "content": f"""Classifique a intenção do usuário.
                
Intenções possíveis:
{intent_descriptions}

Responda APENAS com o nome da intenção."""
            },
            {"role": "user", "content": message}
        ],
        temperature=0
    )
    
    intent = response.choices[0].message.content.strip().lower()
    
    return {
        "intent": intent,
        "confidence": 0.95 if intent in INTENTS else 0.5,
        "message": message
    }

# Uso
result = classify_intent("Quero cancelar minha assinatura")
# {"intent": "cancellation", "confidence": 0.95, ...}

Projeto 5: Gerador de Código com Contexto

Dificuldade: ⭐⭐⭐ Avançado
Tempo: 2 semanas
Por que impressiona: Meta! IA que ajuda a programar

# code_generator.py
from openai import OpenAI
from pathlib import Path

def generate_code_with_context(
    request: str,
    existing_files: list[str],
    language: str = "python"
) -> str:
    """
    Gera código considerando arquivos existentes do projeto.
    """
    client = OpenAI()
    
    # Ler arquivos existentes como contexto
    context_parts = []
    for file_path in existing_files[:5]:  # Limitar para não estourar contexto
        try:
            content = Path(file_path).read_text()
            context_parts.append(f"### {file_path}\n{content}")
        except:
            continue
    
    context = "\n\n".join(context_parts)
    
    prompt = f"""
Você é um programador expert em {language}.

## Código existente no projeto:
{context}

## Tarefa:
{request}

## Instruções:
- Mantenha consistência com o código existente
- Use os mesmos padrões de nomenclatura
- Importe módulos já existentes quando fizer sentido
- Adicione docstrings e comentários

Gere apenas o código, sem explicações.
"""
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2
    )
    
    return response.choices[0].message.content

Projeto 6: Sistema de Moderação de Conteúdo

Dificuldade: ⭐⭐ Intermediário
Tempo: 1 semana
Por que impressiona: Problema real que toda plataforma tem

# moderator.py
from openai import OpenAI
from pydantic import BaseModel

class ModerationResult(BaseModel):
    is_safe: bool
    categories: dict[str, bool]
    confidence: float
    explanation: str

def moderate_content(content: str) -> ModerationResult:
    client = OpenAI()
    
    # Usar API de moderação da OpenAI
    moderation = client.moderations.create(input=content)
    results = moderation.results[0]
    
    # Para casos edge, usar LLM para análise mais profunda
    if any(results.category_scores.__dict__.values() > 0.3):
        analysis = client.chat.completions.create(
            model="gpt-4",
            messages=[
                {
                    "role": "system",
                    "content": """Analise se o conteúdo viola políticas de uso.
                    Categorias: spam, hate_speech, harassment, adult_content, violence
                    Responda em JSON: {"is_safe": bool, "reason": str}"""
                },
                {"role": "user", "content": content}
            ],
            response_format={"type": "json_object"}
        )
        # Processar análise detalhada
    
    return ModerationResult(
        is_safe=not results.flagged,
        categories={k: v for k, v in results.categories.__dict__.items()},
        confidence=1 - max(results.category_scores.__dict__.values()),
        explanation="Conteúdo aprovado" if not results.flagged else "Conteúdo flagged"
    )

Projeto 7: Pipeline de Extração de Dados

Dificuldade: ⭐⭐⭐ Avançado
Tempo: 2 semanas
Por que impressiona: Automatização com IA estruturada

# extractor.py
from openai import OpenAI
from pydantic import BaseModel

class Invoice(BaseModel):
    company_name: str
    invoice_number: str
    date: str
    total_amount: float
    items: list[dict]

def extract_invoice_data(text: str) -> Invoice:
    """
    Extrai dados estruturados de uma fatura em texto livre.
    """
    client = OpenAI()
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "system",
                "content": """Extraia os dados da fatura em formato JSON:
                {
                    "company_name": "nome da empresa",
                    "invoice_number": "número da fatura",
                    "date": "YYYY-MM-DD",
                    "total_amount": 0.00,
                    "items": [{"description": "", "quantity": 0, "price": 0.00}]
                }"""
            },
            {"role": "user", "content": text}
        ],
        response_format={"type": "json_object"}
    )
    
    data = json.loads(response.choices[0].message.content)
    return Invoice(**data)

# Uso
invoice_text = """
FATURA #12345
Empresa: Tech Solutions Ltda
Data: 15/01/2025

Itens:
- Consultoria técnica (10h) - R$ 2.000,00
- Desenvolvimento API - R$ 5.000,00

Total: R$ 7.000,00
"""

invoice = extract_invoice_data(invoice_text)
print(invoice.total_amount)  # 7000.0

Dicas para o README

# 📚 RAG Chatbot - Document Q&A

Um chatbot inteligente que responde perguntas sobre seus documentos usando RAG.

## 🚀 Demo
[Link para o app deployado]

## ✨ Features
- Upload de PDFs e documentos
- Busca semântica com embeddings
- Respostas contextualizadas com GPT-4
- Histórico de conversas

## 🛠️ Tecnologias
- Python 3.11
- LangChain
- OpenAI GPT-4
- ChromaDB
- Streamlit

## 📦 Instalação
```bash
git clone https://github.com/seu-user/rag-chatbot
cd rag-chatbot
pip install -r requirements.txt
```

## 🔧 Configuração
```bash
cp .env.example .env
# Adicione sua OPENAI_API_KEY
```

## 🏃 Rodando
```bash
streamlit run app.py
```

## 📝 Licença
MIT