# Mastra sem mistério: curso grátis de agentes e workflows em TypeScript
> Aprenda Mastra em português: introdução e 16 aulas grátis sobre agentes de IA, tools tipadas com Zod, workflows determinísticos, memória, RAG, MCP, Evals e deploy em TypeScript.
**Autores:** Mauro Mequelussi
**Publicado:** 2026-10-31T21:15:14.118222066Z
**Atualizado:** 2026-10-31T22:00:49.67784268Z
**Tags:** agentes-de-ia, curso-gratis, mastra, mcp, typescript, workflows, em-portugues
---
O **curso grátis Mastra sem mistério em português** da Escola de Aplicativos reúne uma introdução e 16 aulas práticas sobre agentes de IA, ferramentas tipadas com Zod, workflows determinísticos, aprovação humana (`suspend` e `resume`), streaming em tempo real, memória em 4 camadas, RAG e GraphRAG, Workspaces e Sandboxes, Harness, autenticação OAuth, protocolo MCP, observabilidade OpenTelemetry, ciclo de Evals e deploy em produção com TypeScript.

[Assista ao curso completo de Mastra em português](https://l.escoladeaplicativos.com.br/mastra-curso-gratis). A trilha foi organizada para quem quer sair de prompts soltos e construir sistemas de agentes confiáveis, testáveis e observáveis em produção.

## Assista à introdução do curso de Mastra

Um cliente pede estorno de um pedido atrasado, um fornecedor altera o prazo de entrega de grãos especiais e a equipe precisa decidir se aprova um desconto fora da alçada automática. Quando tudo isso depende de um único prompt gigante, o sistema alucina valores, perde o contexto da conversa e executa ações sem auditoria.

Esse é o fio condutor das aulas. Ao longo do curso, construímos o **Pulso**, plataforma de operações da torrefação e assinatura **Nuvem Café**, evoluindo o agente **Theo** desde o primeiro teste no Mastra Studio até uma arquitetura multiagente completa em produção.

::video-player{src="https://www.youtube.com/watch?v=4isQWDaxkyk" title="Mastra sem Mistério: introdução ao curso grátis em português"}
::

## O que é o Mastra e por que usar um framework de agentes em TypeScript?

Mastra é um framework open-source em TypeScript projetado para desenvolver aplicações e sistemas de agentes de IA com engenharia de software de verdade. Em vez de espalhar chamadas de LLM pelo código sem contrato de entrada e saída, o Mastra organiza agentes, ferramentas (`tools`), fluxos em grafo (`workflows`), memória persistente, recuperação de conhecimento (`RAG`), avaliação (`scorers`) e telemetria dentro de uma única instância central.

No cenário do Pulso, separar essas responsabilidades faz toda a diferença. O agente Theo conversa com o cliente e interpreta a intenção, mas a consulta de pedidos roda em uma tool validada com Zod, o estorno financeiro percorre um workflow determinístico com pausa para aprovação humana e as normas da empresa vêm de uma base RAG com citações verificáveis.

A proposta deste curso é dominar cada uma dessas peças com critérios claros de arquitetura: quando usar um agente autônomo, quando preferir uma tool determinística e quando travar a ordem de execução em um workflow.

## Para quem é este curso grátis de Mastra?

O curso foi desenhado para desenvolvedores TypeScript e JavaScript, criadores de SaaS, arquitetos de software e profissionais que constroem produtos digitais com inteligência artificial. Quem já trabalha com Node.js, Next.js, Nuxt, Hono ou Cloudflare Workers vai reconhecer imediatamente os padrões de tipagem com Zod, rotas HTTP e variáveis de ambiente.

Conhecer o básico de TypeScript e JSON facilita o acompanhamento, mas cada aula apresenta a motivação e a arquitetura visual antes de mostrar o código. Se você está começando com engenharia de agentes, assista na sequência desde a introdução e acompanhe a evolução do projeto Pulso no Mastra Studio.

## O que você vai aprender em cada etapa

### 1. Arquitetura, Mastra Studio, Model Router e Tools com Zod

As primeiras aulas estabelecem o modelo mental da engenharia de agentes. Você aprende a árvore de decisão entre **Agente**, **Tool** e **Workflow**, cria o projeto com `npm create mastra@latest` e inspeciona prompts, parâmetros e traces no **Mastra Studio** em `localhost:4111`.

Em seguida, configura o agente Theo com instruções dinâmicas baseadas em `RequestContext`, alterna entre provedores como OpenAI, Anthropic e Google Gemini pelo **Model Router** com fallback automático e impõe contratos estritos de JSON usando `structuredOutput` e `createTool` com schemas Zod (`inputSchema` e `outputSchema`).

### 2. Workflows determinísticos, aprovação humana e streaming

Quando o processo exige ordem previsível, saímos do loop aberto do agente e entramos no motor de grafos do Mastra (`createWorkflow` e `createStep`). Você encadeia etapas com `.then()`, cria ramificações condicionais com `.branch()`, executa tarefas simultâneas com `.parallel()` e repete validações com `.dountil()`.

Para operações críticas — como estornos acima do limite automático na Nuvem Café — você implementa **Human-in-the-Loop** com `suspend()` e `resume()`, persistindo o snapshot do workflow no banco até a decisão da supervisão. Também domina o streaming em tempo real com `.stream()`, `fullStream`, Server-Sent Events (SSE) e integração direta com `@mastra/ai-sdk`.

### 3. Memória em 4 camadas, RAG, GraphRAG e Workspaces

Um agente sem memória repete perguntas; um agente que envia o histórico inteiro estoura a janela de contexto. Você configura `@mastra/memory` em quatro camadas complementares: histórico recente da conversa, **Working Memory** estruturada para preferências do cliente, **Semantic Recall** vetorial de longo prazo e **Observational Memory** com compressão em background pelos agentes Observer e Reflector.

Para responder dúvidas sobre manuais e políticas sem inventar regras, construímos o pipeline completo de **RAG** (`MDocument.fromMarkdown`, `chunk`, embeddings e `createVectorQueryTool`) e avançamos para **GraphRAG**, conectando documentos por entidades compartilhadas. Depois, entregamos um ambiente seguro ao agente com **Workspaces**, filesystem isolado, **Skills** sob demanda (`SKILL.md`) e execução em **Sandbox**.

### 4. Harness, segurança OAuth, MCP e subagentes

Aplicações com agentes que rodam tarefas longas ou operam múltiplos subagentes precisam de coordenação de estado. Você aprende a usar a classe **Harness** para gerenciar modos operacionais (planejamento vs. execução), threads, subagentes e aprovação de chamadas de ferramentas.

Na camada de integração e segurança, conectamos o agente a serviços externos com autenticação OAuth gerenciada, consumimos ferramentas comunitárias via `MCPClient` e expomos nossas próprias capacidades para IDEs como Cursor e Claude Desktop usando `MCPServer`.

### 5. Observabilidade OpenTelemetry, ciclo de Evals e deploy em produção

Não existe sistema de agentes confiável sem medição. Você instrumenta traces completos no Mastra Studio e via **OpenTelemetry** para inspecionar latência, consumo de tokens e chamadas de ferramentas passo a passo.

Depois, fecha o ciclo de melhoria contínua com **Datasets**, **Experiments** e **Scorers** (`@mastra/evals`), medindo fidelidade ao contexto (`faithfulness`), relevância e precisão de uso de ferramentas antes de atualizar prompts em produção. No encerramento, empacota o sistema no **Mastra Server**, acopla a aplicações Next.js, Hono ou Express com Server Adapters e realiza o deploy na **Mastra Cloud**, Cloudflare Workers ou Vercel com checklist completo de segurança e controle de custos.

## Trilha completa: introdução e 16 aulas em português

Use a tabela abaixo para navegar diretamente para uma aula ou siga a ordem completa do curso:

| Ordem | Aula | Assista |
| --- | --- | --- |
| Introdução | de prompts soltos a sistemas de agentes em produção | [Assistir](https://youtu.be/4isQWDaxkyk) |
| Aula 01 | Agente, Tool ou Workflow? Arquitetura e modelo mental | [Assistir](https://youtu.be/fAmOEt-_b84) |
| Aula 02 | Primeiro agente no Mastra Studio, Model Router e Zod | [Assistir](https://youtu.be/K95lJeoPLF8) |
| Aula 03 | Tools tipadas com createTool e ciclo de vida do agente | [Assistir](https://youtu.be/kxSMb29PbOI) |
| Aula 04 | Engenharia de contexto e RequestContext | [Assistir](https://youtu.be/TTbzaN5DZ04) |
| Aula 05 | Sistemas multiagente: Supervisor e subagentes | [Assistir](https://youtu.be/GrDCXTKezqc) |
| Aula 06 | Workflows: createStep, .then, .branch e .parallel | [Assistir](https://youtu.be/zxVIytMX3oQ) |
| Aula 07 | Human-in-the-loop: suspend(), resume() e bail() | [Assistir](https://youtu.be/jxT753AjOpk) |
| Aula 08 | Streaming em tempo real de agentes e workflows | [Assistir](https://youtu.be/LAJf86jRQx4) |
| Aula 09 | Memória em 4 camadas e Observational Memory | [Assistir](https://youtu.be/GEXxk_h53ok) |
| Aula 10 | RAG, Chunking, Vector Stores e GraphRAG | [Assistir](https://youtu.be/EfUsMRob7iw) |
| Aula 11 | Workspaces, Filesystem, Skills e Sandboxes | [Assistir](https://youtu.be/XLPFBQF7v8Y) |
| Aula 12 | Harness: agentes de longo prazo e modos de ação | [Assistir](https://youtu.be/ZZ4Zz1nRqn4) |
| Aula 13 | Autenticação, identidade, OAuth e protocolo MCP | [Assistir](https://youtu.be/mRBI5NiXU0w) |
| Aula 14 | Observabilidade, OpenTelemetry e Tracing | [Assistir](https://youtu.be/cQqDVvOKotQ) |
| Aula 15 | Ciclo de Evals, Scorers e Datasets | [Assistir](https://youtu.be/W_XGcPfdxPQ) |
| Aula 16 | Servidor Hono, deploy em produção e arquitetura | [Assistir](https://youtu.be/-3MSWrCe608) |

[Abra a playlist completa do curso grátis de Mastra no YouTube](https://l.escoladeaplicativos.com.br/mastra-curso-gratis).

## Como estudar e aplicar no seu projeto

A melhor forma de absorver o curso é manter o **Mastra Studio** aberto enquanto acompanha cada aula. Comece criando um agente simples, adicione uma ferramenta com `inputSchema` e `outputSchema` e force entradas inválidas para ver como o Zod protege a execução antes que o erro chegue à API externa.

Ao estudar workflows e memória, observe nos traces do Studio a diferença de custo e previsibilidade entre deixar o modelo decidir tudo sozinho ou guiar o fluxo com passos tipados e Working Memory enxuta.

## Continue sua jornada em engenharia de IA e dados

A arquitetura de agentes conversa diretamente com a escolha do banco de dados e da camada de memória. Para aprofundar seus estudos na Escola de Aplicativos, confira também o [curso grátis de SurrealDB para Engenheiros de IA](/blog/surrealdb-para-engenheiros-de-ia) e o [curso grátis de SurrealDB do zero com CRM](/blog/surrealdb-do-zero).

## Perguntas frequentes sobre o curso de Mastra

### O curso de Mastra é gratuito?

Sim. Todos os 17 vídeos — incluindo a introdução e as 16 aulas práticas — estão disponíveis gratuitamente no canal da Escola de Aplicativos no YouTube.

### Preciso ser avançado em TypeScript para acompanhar?

Não é necessário dominar recursos avançados da linguagem. Conhecendo funções assíncronas (`async/await`), objetos e tipos básicos em TypeScript, você consegue acompanhar todas as demonstrações e esquemas com Zod.

### Posso usar o Mastra com um projeto Next.js, Nuxt ou Hono existente?

Sim. O Mastra pode rodar como um servidor dedicado (`Mastra Server`) ou ser integrado diretamente às rotas do seu back-end Node.js ou edge usando os Server Adapters oficiais.

### Quais modelos de IA funcionam com o Mastra?

Pelo Model Router integrado, você pode usar OpenAI, Anthropic Claude, Google Gemini, Groq, Mistral, modelos open-source e gateways compatíveis usando a string `provedor/modelo`, sem reescrever a lógica do agente.

## Comece agora a construir agentes em produção

[Assista à introdução e acompanhe as 16 aulas na playlist oficial](https://l.escoladeaplicativos.com.br/mastra-curso-gratis). Consulte também a [documentação oficial do Mastra](https://l.escoladeaplicativos.com.br/mastra-oficial) para explorar os pacotes e exemplos atualizados do ecossistema.