Mastra

Routes LLM requests across 50+ model providers (OpenAI, Anthropic, Ollama, local models, etc.) through a unified Provider Registry that handles schema compatibility translation, dynamic model selection based on RequestContext, and automatic fallback chains when primary models fail. Uses a gateway vs direct provider pattern to abstract provider-specific APIs into a normalized interface, enabling seamless model swapping without agent code changes.

Implements a structured agentic loop (The Loop) that orchestrates agent reasoning, tool invocation, and memory updates in a single execution cycle. Agents define tools via a Tool Builder that converts TypeScript functions into JSON Schema, executes them with full RequestContext access, and automatically persists tool results to agent memory (threads). Supports both synchronous and streaming execution modes with built-in error handling and tool validation.

Provides React hooks (useAgent, useWorkflow, useMemory) for integrating agents and workflows into React applications. Hooks manage execution state, streaming responses, and error handling, with built-in support for real-time updates via SSE. Components can trigger agent execution, display streaming results, and access memory/conversation history. Includes a Studio UI playground for testing agents and workflows.

Provides comprehensive observability through distributed tracing (OpenTelemetry integration), structured logging, and an evaluation framework for measuring agent performance. Traces capture agent execution, tool calls, LLM requests, and memory operations. Evaluation system includes scorers for measuring output quality, datasets for benchmarking, and experiments for comparing agent configurations. Exporters support multiple backends (Datadog, New Relic, etc.).

Allows agents to define custom input and output processors that transform messages before/after execution. Input processors validate and normalize user input, output processors format or validate agent responses. Processors are composable and can be chained, enabling complex transformation pipelines. Built-in processors handle common tasks (sanitization, formatting, schema validation).

Enables agents to interact with web browsers, navigate pages, extract content, and perform actions (clicks, form fills, etc.). Built on Playwright or similar browser automation libraries, agents can take screenshots, parse HTML, and execute JavaScript. Useful for agents that need to interact with web applications or scrape dynamic content.

Allows agents and workflows to be customized per-request via RequestContext, enabling dynamic model selection, tool availability, memory thread assignment, and other runtime configuration without code changes. RequestContext is passed through the entire execution pipeline and can override agent defaults. Useful for multi-tenant scenarios or A/B testing different configurations.

Provides voice input/output capabilities through a provider-agnostic voice system supporting multiple speech-to-text and text-to-speech providers (OpenAI, Anthropic, etc.). Agents can accept voice input, process it, and return voice output. Voice providers are abstracted similarly to LLM providers, enabling provider switching without code changes.

Provides React hooks and pre-built components for integrating agents into React applications. Hooks provide access to agent state, memory, and execution status. Components include chat interfaces, message displays, and agent status indicators. All components are styled and customizable, with support for streaming responses and real-time updates. Integrates with the Mastra client SDK for server communication.

Provides a web-based IDE (Mastra Studio) for developing, testing, and debugging agents without leaving the browser. The Studio includes an editor for agent code, a playground for testing agents with different inputs, execution tracing with step-by-step visualization, and memory inspection. Changes in the editor are hot-reloaded in the playground. Includes integration with the observability system for detailed execution analysis.

Provides a JavaScript/TypeScript client library for communicating with Mastra servers from browsers or Node.js applications. The SDK handles HTTP requests, streaming responses, authentication, and error handling. Includes methods for invoking agents, querying memory, managing workflows, and accessing storage. Supports both REST and streaming transports.

Provides a workflow system that chains multiple steps (agents, tools, custom functions) with state persistence and suspend/resume capabilities. Steps are composed declaratively and executed through pluggable execution engines (local, Inngest for durability). Supports control flow patterns (if/else, loops, parallel execution) and automatically persists workflow state to enable resumption after failures or long-running operations. Inngest integration provides durable execution with automatic retries and event-driven triggering.

Implements a complete RAG system with document ingestion, chunking, embedding generation, and semantic search across multiple vector storage backends (PostgreSQL pgvector, LibSQL, custom). Documents are processed through configurable chunking strategies, embedded via provider-agnostic embedding models, and indexed for similarity search. Agents can retrieve relevant documents via semantic queries and inject them into context, with built-in support for hybrid search (semantic + keyword) and reranking.

Manages agent conversation history and context through a thread-based memory model where each agent instance has a thread containing messages (user, assistant, tool results). Threads are persisted to configurable storage backends (PostgreSQL, LibSQL) and support message filtering, retrieval, and context window management. Agents automatically append new messages to their thread after each execution step, creating a persistent conversation history that survives restarts.

Integrates the Model Context Protocol to enable agents to discover and execute tools from MCP servers dynamically. MCP servers expose tool schemas and implementations, which Mastra translates into agent-executable tools. Supports both local MCP servers and remote servers, with automatic schema translation and error handling. Agents can invoke MCP tools the same way as native tools, creating a unified tool execution model.

Enables agents to generate structured outputs (JSON, typed objects) by defining schemas via Zod or JSON Schema and validating LLM responses against them. Agents can request structured output from LLMs, which automatically validates and parses responses into typed objects. Supports schema composition, nested objects, and custom validation rules. Failed validations trigger re-prompting or error handling.

Supports building networks of agents that collaborate by passing messages, sharing memory, and coordinating on tasks. Agents can invoke other agents as tools, creating hierarchical or peer-to-peer collaboration patterns. Shared memory (threads) can be accessed by multiple agents, enabling context sharing. Agent networks are orchestrated through workflows or custom coordination logic.

Provides a production-ready server API that exposes agents and workflows via HTTP endpoints, with support for streaming responses via Server-Sent Events (SSE). Includes adapters for Hono, Express, Fastify, and Koa, enabling deployment to any Node.js framework. Endpoints support both request/response and streaming modes, with built-in authentication, error handling, and CORS support. A2A (Agent-to-Agent) protocol enables inter-service agent communication.

Provides a command-line interface for creating new Mastra projects, running a development server with hot-reload, and building for production. The dev server watches for file changes and reloads agents/workflows without restarting, enabling rapid iteration. Project scaffolding creates a starter template with example agents, workflows, and storage configuration. Build system handles bundling and dependency analysis.