Módulo 2B.3: Criação de Agentes Educacionais com IA

**Nível 2B: Técnico

Carga Horária: 15 horas**

📖 Visão Geral

Aprenda a criar agentes autônomos de IA capazes de executar tarefas complexas em educação. Domine frameworks como LangChain Agents, AutoGPT e CrewAI para construir tutores personalizados, geradores de conteúdo e assistentes de pesquisa que agem com mínima supervisão humana.

Objetivos:

Entender arquitetura de agentes (ReAct, Plan-and-Execute)
Implementar agente com ferramentas customizadas
Criar tutor socrático que faz perguntas ao invés de dar respostas
Construir gerador de conteúdo multi-step (pesquisa + síntese + validação)
Orquestrar múltiplos agentes (multi-agent systems)

🤖 O que são Agentes de IA?

Definição:

Agente = LLM + Ferramentas + Loop de Raciocínio

Diferença de Chatbot:

Chatbot:

User: "Qual a capital da França?"
LLM: "A capital da França é Paris."
[1 turno, resposta direta]

Agente:

User: "Me dê informações atualizadas sobre Paris"

Agent (interno):
1. Thought: "Preciso buscar informações recentes"
2. Action: google_search("Paris novidades 2025")
3. Observation: [Resultados da busca]
4. Thought: "Preciso sintetizar em tópicos"
5. Action: None (raciocínio suficiente)
6. Final Answer: "Aqui estão 5 novidades sobre Paris..."

[Multi-step, usa ferramentas, raciocínio iterativo]

🧩 Arquitetura de Agentes

Componente 1: Brain (LLM)

Função: Raciocínio e decisão

Modelos Recomendados:

GPT-4: Melhor raciocínio, mais caro
GPT-3.5: Bom custo-benefício
Claude 3: Forte em reasoning chains
LLaMA 3 70B: Open-source, mas requer infra

Componente 2: Tools (Ferramentas)

Função: Ações que agente pode executar

Exemplos Educacionais:

tools = [
    Tool(
        name="Buscar_Biblioteca",
        func=buscar_em_pdfs,
        description="Busca informação em materiais do curso"
    ),
    Tool(
        name="Gerar_Quiz",
        func=gerar_questoes,
        description="Cria questões de múltipla escolha sobre tópico"
    ),
    Tool(
        name="Avaliar_Resposta",
        func=corrigir_resposta,
        description="Avalia resposta do aluno (0-10)"
    ),
    Tool(
        name="Recomendar_Material",
        func=recomendar_recurso,
        description="Sugere material baseado em dificuldades"
    )
]

Anatomia de uma Tool:

Nome: Identificador único
Função: Código Python que executa
Descrição: Como LLM entende quando usar (crítico!)

Componente 3: Memory (Memória)

Função: Lembrar interações passadas

Tipos:

Short-term (Conversa Atual):

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context(
    {"input": "Olá"},
    {"output": "Olá! Como posso ajudar?"}
)

Long-term (Entre Sessões):

from langchain.memory import VectorStoreRetrieverMemory

# Armazena em vector DB, busca por similaridade
memory = VectorStoreRetrieverMemory(retriever=vectordb.as_retriever())

Componente 4: Agent Loop (Ciclo de Raciocínio)

Framework: ReAct (Reasoning + Acting)

Loop até responder:
REASON: "Que informação preciso?"
ACT: Usar ferramenta
OBSERVE: Ver resultado
[Repetir ou finalizar]

Exemplo Real:

User: "Crie quiz sobre fotossíntese para 8º ano"

Iteration 1:
├─ Thought: "Preciso saber o que alunos já aprenderam"
├─ Action: Buscar_Biblioteca(tópico="fotossíntese", série="8º ano")
└─ Observation: "Alunos já viram cloroplastos, mas não Calvin cycle"

Iteration 2:
├─ Thought: "Vou criar questões focadas no nível deles"
├─ Action: Gerar_Quiz(tópico="fotossíntese", nível="intermediário", n=5)
└─ Observation: [5 questões geradas]

Iteration 3:
├─ Thought: "Questões estão boas, posso responder"
├─ Action: None
└─ Final Answer: "Aqui está seu quiz: [QUESTÕES]"

🛠️ Implementação: Tutor Socrático

Objetivo:

Criar agente que ensina fazendo perguntas (método socrático), não dando respostas diretas.

Código (LangChain):

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory

# Ferramentas
def avaliar_compreensao(resposta_aluno: str) -> str:
    """Avalia se aluno entendeu conceito baseado na resposta"""
    prompt = f"""
    Resposta do aluno: {resposta_aluno}

    Analise:
    1. Aluno demonstrou compreensão? (Sim/Parcial/Não)
    2. Conceitos corretos mencionados
    3. Misconceptions identificadas

    Formato: JSON
    """
    # [Chamar LLM para analisar]
    return resultado

def gerar_pergunta_socratica(topico: str, nivel_dificuldade: str) -> str:
    """Gera pergunta que leva aluno a descobrir resposta"""
    prompt = f"""
    Tópico: {topico}
    Nível: {nivel_dificuldade}

    Crie pergunta socrática que:
    - Não dá resposta direta
    - Faz aluno pensar e conectar conceitos
    - Usa analogias ou contra-exemplos

    Exemplo ruim: "O que é fotossíntese?"
    Exemplo bom: "Se plantas precisam de luz solar, como sobrevivem em florestas densas?"
    """
    # [Chamar LLM]
    return pergunta

tools = [
    Tool(
        name="Avaliar_Compreensao",
        func=avaliar_compreensao,
        description="Usa isto quando aluno responder uma pergunta. Retorna análise de compreensão."
    ),
    Tool(
        name="Gerar_Pergunta",
        func=gerar_pergunta_socratica,
        description="Usa isto para criar próxima pergunta baseada em tópico e nível."
    )
]

# System Prompt
system_prompt = """
Você é um tutor socrático de biologia.

Regras:
1. NUNCA dê respostas diretas
2. SEMPRE faça perguntas que levem aluno a descobrir
3. Use analogias e exemplos do cotidiano
4. Se aluno errar, faça pergunta mais simples
5. Se acertar, aprofunde com pergunta mais complexa
6. Seja encorajador e paciente

Ferramentas disponíveis: {tools}

Formato de resposta:
Thought: [Seu raciocínio]
Action: [Ferramenta a usar]
Action Input: [Input da ferramenta]
Observation: [Resultado da ferramenta]
... (repita Thought/Action/Observation até ter resposta)
Final Answer: [Sua pergunta para o aluno]
"""

# Inicializar agente
llm = OpenAI(temperature=0.7, model="gpt-4")
memory = ConversationBufferMemory(memory_key="chat_history")

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent="conversational-react-description",
    memory=memory,
    verbose=True,  # Ver raciocínio interno
    system_message=system_prompt
)

# Usar
response = agent.run("Quero entender fotossíntese")
print(response)

Output Esperado:

Thought: Aluno quer entender fotossíntese. Vou começar descobrindo conhecimento prévio.
Action: Gerar_Pergunta
Action Input: {"topico": "fotossíntese", "nivel_dificuldade": "iniciante"}
Observation: "Você já viu plantas em lugares diferentes (sombra vs sol). O que você nota de diferente nelas?"

Final Answer: Ótimo! Vamos explorar fotossíntese juntos. Para começar: você já percebeu que plantas crescem em lugares diferentes - algumas no sol, outras na sombra. O que você acha que muda em plantas que ficam em locais muito ensolarados comparado às que ficam na sombra?

🎓 Caso 2: Gerador de Conteúdo Multi-Step

Objetivo:

Agente que cria aula completa:

Pesquisa tópico
Estrutura conteúdo
Gera materiais (slides, quiz, atividades)
Valida qualidade

Arquitetura Plan-and-Execute:

from langchain.agents import create_plan_and_execute_agent
from langchain.tools import Tool

# Fase 1: PLAN
plan_prompt = """
Tarefa: Criar aula de 50min sobre {topico} para {publico}

Crie plano com:
1. Objetivos de aprendizagem (3-5)
2. Estrutura da aula (tempo em minutos)
3. Materiais necessários
4. Forma de avaliação

Formato: Lista numerada de passos acionáveis
"""

# Fase 2: EXECUTE
# Agente executa cada passo do plano usando ferramentas

tools = [
    Tool(
        name="Pesquisar_Conteudo",
        func=pesquisar_web_e_pdfs,
        description="Busca informações atualizadas sobre tópico"
    ),
    Tool(
        name="Gerar_Slide",
        func=criar_slide_markdown,
        description="Cria slide em markdown com título, conteúdo, imagens"
    ),
    Tool(
        name="Gerar_Quiz",
        func=criar_questoes,
        description="Cria questões de múltipla escolha"
    ),
    Tool(
        name="Validar_Qualidade",
        func=revisar_conteudo,
        description="Verifica se conteúdo está adequado (Bloom, BNCC, etc)"
    )
]

agent = create_plan_and_execute_agent(
    llm=llm,
    tools=tools,
    verbose=True
)

# Executar
resultado = agent.run(
    "Crie aula sobre Inteligência Artificial para ensino médio (15-17 anos)"
)

Output:

Plan:
1. Pesquisar: conceitos de IA adequados para ensino médio
2. Estruturar: aula de 50min (5min intro, 20min conceitos, 15min prática, 10min avaliação)
3. Criar: 10 slides sobre IA (história, tipos, ética)
4. Gerar: 5 questões de múltipla escolha
5. Validar: checar alinhamento com BNCC
6. Empacotar: ZIP com slides + quiz + plano de aula

Executing Step 1...
[Agente usa ferramenta Pesquisar_Conteudo]
Found: "IA é campo da computação que simula inteligência humana..."

Executing Step 2...
[Agente raciocina sobre estrutura]
Structure: Intro (historia) → Tipos (supervised/unsupervised/RL) → Etica → Hands-on

...

Final Package:
├── aula_ia.md (10 slides)
├── quiz_ia.json (5 questões)
├── plano_aula.pdf
└── recursos_adicionais.txt

🤝 Multi-Agent Systems

Conceito:

Múltiplos agentes especializados trabalhando juntos.

Exemplo: Criação de Curso Completo

Agente 1 - Pesquisador:
└─ Busca conteúdo, papers, exemplos

Agente 2 - Designer Instrucional:
└─ Estrutura curso seguindo ADDIE

Agente 3 - Criador de Conteúdo:
└─ Gera aulas, slides, atividades

Agente 4 - Avaliador:
└─ Cria quizzes, rubricas

Agente 5 - Revisor:
└─ Valida qualidade, corrige erros

Implementação (CrewAI):

from crewai import Agent, Task, Crew

# Definir agentes
pesquisador = Agent(
    role="Pesquisador Educacional",
    goal="Encontrar conteúdo de qualidade sobre {topico}",
    backstory="Você é PhD em Educação com 15 anos pesquisando métodos eficazes",
    tools=[google_search, arxiv_search, wikipedia],
    verbose=True
)

designer = Agent(
    role="Designer Instrucional",
    goal="Estruturar aprendizagem seguindo melhores práticas",
    backstory="Especialista em ADDIE, Bloom, Merrill",
    tools=[criar_estrutura, alinhar_bncc],
    verbose=True
)

criador = Agent(
    role="Criador de Conteúdo",
    goal="Gerar materiais envolventes e claros",
    backstory="Você é professor com 10 anos criando recursos didáticos",
    tools=[gerar_slide, gerar_atividade, gerar_video_script],
    verbose=True
)

revisor = Agent(
    role="Revisor de Qualidade",
    goal="Garantir excelência pedagógica",
    backstory="Coordenador pedagógico rigoroso com olho para detalhes",
    tools=[validar_conteudo, checar_acessibilidade],
    verbose=True
)

# Definir tarefas
task1 = Task(
    description="Pesquisar sobre {topico} e compilar 10 melhores recursos",
    agent=pesquisador
)

task2 = Task(
    description="Criar estrutura de curso de 12h baseado na pesquisa",
    agent=designer
)

task3 = Task(
    description="Gerar materiais para os 6 módulos do curso",
    agent=criador
)

task4 = Task(
    description="Revisar todos os materiais e sugerir melhorias",
    agent=revisor
)

# Criar crew (equipe)
crew = Crew(
    agents=[pesquisador, designer, criador, revisor],
    tasks=[task1, task2, task3, task4],
    verbose=True
)

# Executar
resultado = crew.kickoff(inputs={"topico": "Pensamento Computacional para Ensino Fundamental"})

print(resultado)

Output:

[Pesquisador]: Encontrei 10 recursos sobre pensamento computacional...
[Designer]: Estruturei curso em 6 módulos: 1) Decomposição, 2) Padrões...
[Criador]: Gerados 6 conjuntos de materiais com 18 atividades...
[Revisor]: Validação completa. Sugestões: Módulo 3 muito denso, sugiro dividir...

Final Result:
✅ Curso de 12h estruturado
✅ 18 atividades hands-on
✅ 6 avaliações formativas
✅ Alinhado com BNCC (EF05MA05, EF67LP04...)

⚠️ Challenges e Limitações

1. Loops Infinitos

Problema: Agente fica preso em ciclo

Thought: Preciso de mais informação
Action: Buscar
Observation: [Resultados]
Thought: Preciso de mais informação
Action: Buscar
[LOOP INFINITO]

Solução:

agent = initialize_agent(
    ...,
    max_iterations=10,  # Limitar iterações
    early_stopping_method="generate"  # Forçar resposta após max
)

2. Uso Excessivo de Ferramentas

Problema: Agente usa 10 ferramentas para tarefa simples (custo $$)

Solução: Few-shot Examples

system_prompt = """
Você é um agente eficiente.

Bons exemplos:
User: "Qual a capital da França?"
Thought: Sei a resposta, não preciso de ferramentas
Action: None
Final Answer: "Paris"

User: "Pesquise últimas notícias sobre IA"
Thought: Preciso buscar informação atualizada
Action: google_search("IA novidades 2025")
[Usa ferramenta apropriadamente]
"""

3. Alucinação de Ferramentas

Problema: Agente inventa ferramentas que não existem

Action: Ferramenta_Magica(input="resolver tudo")
[ERRO: Ferramenta não existe]

Solução: Descrições Claras

# Ruim
Tool(name="Search", description="Busca coisas")

# Bom
Tool(
    name="Buscar_Biblioteca_Curso",
    description="Busca informação APENAS nos PDFs do curso XYZ. Use quando aluno perguntar sobre conteúdo do curso. NÃO use para informações gerais da web."
)

📊 Avaliação de Agentes

Métricas:

1. Task Success Rate

De 100 tarefas, quantas o agente completou corretamente?
Taxa de sucesso = 85/100 = 85%

2. Average Steps to Completion

Quantos passos (iterações) agente precisa em média?
Menos é melhor (eficiência)

3. Tool Usage Efficiency

Agente usa ferramenta certa na primeira tentativa?
Ou fica tentando várias até achar?

4. Cost per Task

Custo médio (tokens API) para completar tarefa
Importante para escala

Teste A/B:

# Agente A: GPT-3.5 (barato, rápido)
# Agente B: GPT-4 (caro, melhor raciocínio)

test_cases = [
    "Crie quiz sobre mitose para 9º ano",
    "Explique relatividade para ensino médio",
    ...  # 50 casos
]

for case in test_cases:
    result_a = agent_a.run(case)
    result_b = agent_b.run(case)

    # Avaliar qualidade (humano ou LLM)
    score_a = avaliar(result_a)
    score_b = avaliar(result_b)

    # Comparar custo
    cost_a = calcular_custo(result_a.tokens)
    cost_b = calcular_custo(result_b.tokens)

# Decidir: GPT-4 vale 10x o custo?

🎨 Casos de Uso Avançados

1. Assistente de Pesquisa Acadêmica

Ferramentas:

Buscar ArXiv (papers científicos)
Buscar Google Scholar
Extrair informações de PDFs
Sintetizar múltiplas fontes
Gerar citações (APA/ABNT)

Fluxo:

User: "Pesquise sobre gamificação em educação STEM"

Agent:
Busca ArXiv + Scholar (últimos 3 anos)
Filtra top 10 papers mais citados
Lê abstracts
Sintetiza em 5 insights principais
Gera bibliografia formatada

2. Gerador de Trilhas Personalizadas

Ferramentas:

Avaliar conhecimento prévio (quiz diagnóstico)
Mapear currículo
Recomendar recursos
Gerar cronograma

Fluxo:

User: "Quero aprender Python para Data Science"

Agent:
1. Aplica quiz diagnóstico (10 questões)
2. Identifica: "Usuário sabe programação básica, mas zero estatística"
3. Cria trilha:
   - Semana 1-2: Pandas + NumPy
   - Semana 3-4: Estatística descritiva
   - Semana 5-6: Visualização (Matplotlib)
   - Semana 7-8: Machine Learning intro
4. Recomenda recursos específicos para cada semana
5. Gera cronograma adaptado a "3h/semana disponível"

3. Moderador de Fóruns Educacionais

Ferramentas:

Detectar toxicidade
Classificar tipo de pergunta
Sugerir recursos relevantes
Conectar alunos com dúvidas similares
Notificar professor quando necessário

Fluxo:

Novo post: "Não entendo polinômios, socorro!"

Agent:
1. Classifica: "Pedido de ajuda em matemática"
2. Busca posts similares: "3 alunos com mesma dúvida esta semana"
3. Sugere: "Olá! Vi que 3 colegas têm dúvida similar. Que tal formarem grupo de estudo? Aqui está vídeo explicativo: [link]"
4. Notifica professor: "4 alunos com dificuldade em polinômios - considere aula de reforço"

📦 Recursos do Módulo

📹 Videoaulas (4h)

Fundamentos de agentes (ReAct, Plan-Execute) (50 min)
Implementando agente com LangChain (60 min)
Multi-agent systems (60 min)
Troubleshooting e otimização (50 min)

💬 Práticas (9h)

Criar tutor socrático (3h)
Implementar gerador de conteúdo multi-step (3h)
Construir sistema multi-agente (3h)

✅ Avaliação (2h)

Projeto: Agente funcional com ≥3 ferramentas customizadas
Demonstração: Resolver 5 tarefas educacionais
Análise: Comparar performance (GPT-3.5 vs GPT-4, single vs multi-agent)

📚 Referências

Paper: “ReAct: Synergizing Reasoning and Acting in Language Models” (Yao et al, 2022)
Docs: LangChain Agents (python.langchain.com/docs/modules/agents)
Framework: CrewAI (docs.crewai.com)
Curso: DeepLearning.AI - Building AI Agents

Licença MIT**