Enter your search text in the box above

Select a result to preview

#Agentes #Inteligencia-artificial #Carreira

Construindo um Agente de IA para Simulação de Entrevistas Técnicas com Gemini e OpenClaw

Esta documentação técnica foi estruturada como um guia conceitual e prático para professores, alunos e desenvolvedores interessados em entender a arquitetura de Agentes de IA e como implementá-los na prática para simular entrevistas de emprego reais em tecnologia.

1. O que é um Agente de IA?

A Inteligência Artificial evoluiu de sistemas de chat puramente reativos para entidades autônomas capazes de agir. Diferente de um chatbot comum, que vive preso a uma interface de chat e apenas responde a perguntas diretas, um Agente de IA possui autonomia. Ele consegue:

A Analogia do "Pinóquio"

Para fins didáticos (ideal para salas de aula e explicações simples), podemos dividir a arquitetura de um agente em três componentes essenciais:

                  ┌───────────────────────────┐
                  │      1. O CÉREBRO         │
                  │   (Modelo LLM / API)      │
                  └─────────────┬─────────────┘
                                │
                  ┌─────────────▼─────────────┐
                  │       2. O CORPO          │
                  │  (Plataforma/Orquestrador)│
                  └─────────────┬─────────────┘
                                │
                  ┌─────────────▼─────────────┐
                  │       3. O CHÃO           │
                  │   (Ambiente/Sandbox)      │
                  └───────────────────────────┘
  1. O Cérebro (Modelo/LLM): É o motor de raciocínio lógico e processamento de linguagem (ex: Gemini, GPT, Claude, Llama). Ele não executa ações diretamente no computador, apenas processa os dados e decide "o que fazer".
  2. O Corpo (Plataforma/Orquestrador): É o software que dá "mãos e pernas" ao cérebro (ex: OpenClaw, Hermes, Antigravity, CrewAI). Ele traduz as decisões do cérebro em chamadas de sistema, requisições HTTP e execução de código.
  3. O Chão (Ambiente/Sandbox): É o ambiente isolado onde o agente opera (ex: Docker, WSL/Linux, VPS). Por questões de segurança, nunca devemos rodar agentes com permissões amplas diretamente no nosso sistema operacional nativo (Windows/macOS), pois um agente autônomo pode tomar decisões destrutivas, como deletar arquivos importantes ou derrubar bancos de dados.

2. O Conceito de "Skills" (Habilidades)

Enquanto o prompt tradicional instrui a IA sobre como agir ("Atue como um programador sênior"), uma Skill (Habilidade) confere ao agente a capacidade de executar ações estruturadas.

3. Preparando o "Chão" (Ambiente de Desenvolvimento)

Para rodar o OpenClaw de forma completa, o uso de ambientes baseados em Linux (WSL no Windows) ou Docker é obrigatório. O OpenClaw rodando de forma nativa no Windows possui diversas limitações em suas habilidades.

Pré-requisitos

Passo 1: Estrutura de Arquivos

Crie um diretório para o projeto com a seguinte estrutura:

meu-agente/
├── docker-compose.yml
├── .env
└── skills/
    └── interview-agent/
        └── skill.md

Passo 2: Configuração do .env

Crie um arquivo .env na raiz do projeto e configure suas chaves de API:

# Chave de API do Gemini (Google AI Studio)
GOOGLE_API_KEY=sua_chave_aqui

# Caso queira usar OpenAI, descomente a linha abaixo:
# OPENAI_API_KEY=sua_chave_aqui

Passo 3: Configuração do docker-compose.yml

O arquivo docker-compose.yml automatiza o download e a execução do contêiner do OpenClaw, montando a pasta de skills local dentro do contêiner.

version: '3.8'

services:
  openclaw:
    image: openclaw/openclaw:latest
    container_name: openclaw_agent
    volumes:
      - ./skills:/app/skills
      - openclaw_data:/app/data
    environment:
      - GOOGLE_API_KEY=${GOOGLE_API_KEY}
      - OPENAI_API_KEY=${OPENAI_API_KEY}
    ports:
      - "8000:8000" # Porta da API/WebSocket do OpenClaw
      - "3000:3000" # Porta do Dashboard Web (se aplicável)
    restart: unless-stopped

volumes:
  openclaw_data:

Para iniciar o ambiente, execute o comando abaixo no terminal da pasta raiz:

docker compose up -d

4. Criando a Skill do Entrevistador (interview-agent)

Abaixo está o código Markdown completo da Skill que deve ser salvo no caminho ./skills/interview-agent/skill.md. Esta skill instrui o OpenClaw a se comportar como um entrevistador técnico corporativo de alto nível, gerando saídas estruturadas em JSON para facilitar integrações futuras.

---
name: interview-agent
description: Agente especialista em conduzir simulações de entrevistas técnicas com base em descrições de vagas reais.
---

# Skill de Simulação de Entrevistas Técnicas

Use esta skill sempre que o usuário solicitar a análise de uma vaga de emprego, a criação de um roteiro de entrevista, a condução de perguntas técnicas ou a geração de um relatório de feedback de candidatura.

## Diretrizes Gerais e Guardrails
*   **Foco Absoluto:** Conduza a simulação de forma estritamente profissional. Não responda a perguntas fora do contexto de entrevistas técnicas.
*   **Execução Segura:** Não execute comandos de terminal, não tente ler arquivos do sistema operacional e não faça requisições externas sem autorização.
*   **Condução Oral Dinâmica:** Faça apenas **uma pergunta por vez**. Nunca envie uma lista de perguntas de uma vez só.
*   **Sigilo de Rúbrica:** Nunca revele as respostas ideais ou os critérios de avaliação exatos para o candidato durante a entrevista.


---

## Fluxo de Execução

### Fase 1: Análise da Vaga

Quando o usuário fornecer a descrição de uma vaga de emprego, analise o texto e gere uma resposta estritamente estruturada em JSON com o seguinte formato:

\```json
{
  "vaga": "Nome do Cargo",
  "nivel": "Júnior / Pleno / Sênior / Specialist",
  "competencias_tecnicas": ["Tecnologia 1", "Tecnologia 2"],
  "competencias_comportamentais": ["Soft Skill 1", "Soft Skill 2"],
  "sinais_de_alerta_risco": ["O que indica falta de senioridade para esta vaga"]
}
\```

### Fase 2: Plano de Entrevista

A partir da análise da vaga, elabore um plano de entrevista estruturado internamente.
*   **Se a vaga for Sênior/Especialista:** O plano deve focar em design de sistemas (System Design), tradeoffs de arquitetura, escalabilidade, segurança e gestão de incidentes críticos.
*   **Se a vaga for Júnior/Pleno:** O plano deve focar em fundamentos de programação, algoritmos, boas práticas de código (Clean Code) e ferramentas do dia a dia.

Gere o plano no formato JSON:

\```json
{
  "foco_da_avaliacao": "Objetivo principal da entrevista",
  "blocos_de_perguntas": [
    {
      "bloco": 1,
      "tema": "Arquitetura e Sistemas Críticos",
      "perguntas_sugeridas": ["Pergunta A", "Pergunta B"]
    }
  ]
}
\```

### Fase 3: Condução da Entrevista (Interação Dinâmica)

Inicie a entrevista fazendo a primeira pergunta ao candidato.
*   Aguarde a resposta do usuário.
*   Avalie a resposta internamente usando os critérios da Fase 4.
*   **Ajuste Dinâmico:** Use a resposta do candidato para direcionar a próxima pergunta. Se o candidato citar uma tecnologia específica (ex: "trabalhei com microsserviços usando Kafka"), aprofunde a próxima pergunta nesse ponto para validar a profundidade técnica real.
*   Mantenha o formato padrão de envio de pergunta:
    `Pergunta [N]: [Texto da Pergunta]`

### Fase 4: Avaliação de Respostas (Interna)

Para cada resposta dada, execute uma classificação de desempenho interna:
*   **Fraco:** Resposta superficial, conceitualmente incorreta, sem evidências práticas ou que apresente riscos técnicos graves.
*   **Aceitável:** Resposta correta nos conceitos teóricos, mas com pouca profundidade prática ou falta de clareza nos tradeoffs.
*   **Forte:** Resposta rica em detalhes, demonstra vivência prática real, cita tradeoffs, decisões de arquitetura e resolução de problemas complexos.

### Fase 5: Relatório Final de Desempenho

Quando a entrevista for finalizada (ou o usuário solicitar o relatório), consolide a avaliação em um relatório estruturado em JSON:

\```json
{
  "resumo_executivo": "Parecer geral sobre o candidato",
  "aderencia_ao_cargo": "Baixa / Média / Alta",
  "pontos_fortes": ["Ponto Forte 1", "Ponto Forte 2"],
  "riscos_e_lacunas": ["Lacuna identificada 1", "Lacuna identificada 2"],
  "competencias_avaliadas": [
    {
      "competencia": "Nome da Competência",
      "avaliacao": "Fraco / Aceitável / Forte",
      "evidencia": "O que o candidato disse que comprova isso"
    }
  ],
  "recomendacoes_de_estudo": ["Tópico de Estudo 1", "Tópico de Estudo 2"]
}
\```

5. Executando e Simulando a Entrevista

Uma vez configurado o contêiner Docker e salva a skill, podemos interagir com o agente.

Inicializando o OpenClaw Dashboard

Para gerenciar o agente visualmente, acesse o painel web do OpenClaw. No terminal do contêiner Docker, execute:

openclaw dashboard

Isso abrirá uma interface web local (geralmente em http://localhost:3000 ou http://localhost:8000).

O Processo de Bootstrapping (Configuração Inicial)

Na primeira execução, o agente precisa passar por um bootstrapping (configuração de identidade). Ele fará perguntas para definir sua persona. Responda de forma direta no chat:

  1. Quem é você? "Você é o José, um entrevistador técnico profissional, com tom corporativo sério, sem uso de emojis."
  2. Qual seu fuso horário? "América/Sao_Paulo (Fuso de Brasília)."

Iniciando a Simulação

Envie o comando para ativar a skill criada:

Use a skill interview-agent

Em seguida, envie a descrição da vaga que deseja simular. O agente executará a Fase 1 (Análise) e a Fase 2 (Plano), retornando os JSONs estruturados. Ele então iniciará a Fase 3 (Condução) com a primeira pergunta:

José (Agente): "Pergunta 1: Me conte sobre o sistema backend mais crítico em que você trabalhou. Qual era seu papel e qual era o impacto disso no negócio?"

Exemplo de Interação Dinâmica e Ajuste de Rota

Note que o agente abandonou qualquer roteiro estático para aprofundar-se exatamente na arquitetura que você citou, simulando perfeitamente a postura de um entrevistador técnico sênior de grandes big techs.

6. Solução de Problemas (Troubleshooting)

Durante o desenvolvimento do laboratório prático, diversos problemas de ambiente podem surgir. Abaixo estão as correções documentadas para as falhas mais comuns:

Sintoma 1: O contêiner Docker sobe, mas o agente não reconhece as novas Skills

Sintoma 2: Erros de escrita ao criar arquivos de Skill dentro do Docker

Sintoma 3: O agente alucina e começa a responder suas próprias perguntas

7. Reflexão de Carreira: O Paradigma "AI-First"

A live encerra com uma profunda reflexão sobre o mercado de trabalho atual.

Tópicos Relacionados