Build a Mastra TypeScript Agent Pipeline That Remembers Everything Across Sessions in 2026

Why Mastra for TypeScript Teams

Mastra is the TypeScript-first agent framework that treats AI agents as TypeScript workflows. Unlike LangChain.js or Vercel AI SDK, Mastra provides memory, tools, MCP, workflows, evaluations, and observability in a single framework. It is used in production by Replit, Sanity, and WorkOS teams.

The key differentiator: Mastra agents are TypeScript functions with full type safety. You get autocompletion, compile-time checks, and refactoring support for your agent code. No more debugging Python type hints at runtime.

Architecture: Memory + Workflows + MCP

flowchart TD
    A[User Request] --> B[Mastra Agent]
    B --> C[Valkey Memory Store]
    B --> D[MCP Tool Router]
    B --> E[Workflow Engine]
    C --> F[Session Context]
    C --> G[Long-Term Memory]
    D --> H[External APIs]
    E --> I[Step-by-Step Execution]

Agent Implementation (src/agent.ts)

// src/agent.ts
import { Mastra } from '@mastra/core';
import { Agent } from '@mastra/core/agent';
import { openai } from '@mastra/openai';
import { ValkeyMemory } from '@mastra/valkey';
import { MCPTool } from '@mastra/mcp';

// Initialize Valkey (Redis fork) memory
const memory = new ValkeyMemory({
  url: process.env.VALKEY_URL || 'redis://localhost:6379',
  sessionId: 'user-session-{userId}',
  lastMessages: 20,  // Keep last 20 messages in working memory
  threads: true,     // Enable thread-based memory
});

// Define the agent with MCP tools
const supportAgent = new Agent({
  name: 'customer-support-agent',
  instructions: `You are a customer support agent for a SaaS platform.
    You have access to the knowledge base, ticket system, and user database.
    Always check memory for previous context before asking questions.
    Cite previous conversations when relevant.`,
  model: openai('gpt-5.6-luna'),
  memory,
  tools: {
    search_knowledge: MCPTool.from('knowledge-base-server', 'search'),
    create_ticket: MCPTool.from('jira-server', 'create_issue'),
    get_user: MCPTool.from('database-server', 'query_user'),
  },
});

// Initialize Mastra
const mastra = new Mastra({
  agents: { supportAgent },
  memory,
});

export { mastra, supportAgent };

Workflow Definition (src/workflows/support-ticket.ts)

// src/workflows/support-ticket.ts
import { Workflow, Step } from '@mastra/core/workflows';
import { z } from 'zod';

const classifyTicket = new Step({
  id: 'classify',
  input: z.object({ message: z.string(), userId: z.string() }),
  output: z.object({ category: z.string(), urgency: z.string() }),
  execute: async ({ input, mastra }) => {
    const agent = mastra.getAgent('supportAgent');
    const result = await agent.generate(
      `Classify this support ticket: ${input.message}
       Return JSON with category (billing, technical, feature_request) and urgency (low, medium, high).`
    );
    return JSON.parse(result.text);
  },
});

const resolveTicket = new Step({
  id: 'resolve',
  input: z.object({ message: z.string(), category: z.string(), urgency: z.string() }),
  output: z.object({ response: z.string(), resolved: z.boolean() }),
  execute: async ({ input, mastra }) => {
    const agent = mastra.getAgent('supportAgent');
    const result = await agent.generate(
      `You are resolving a ${input.category} ticket with ${input.urgency} urgency.
       Customer message: ${input.message}
       Provide a helpful resolution.`,
      { threadId: input.category }
    );
    return { response: result.text, resolved: true };
  },
});

const supportWorkflow = new Workflow({
  name: 'support-ticket-workflow',
  triggerSchema: z.object({ message: z.string(), userId: z.string() }),
})
  .step(classifyTicket)
  .then(resolveTicket)
  .commit();

export { supportWorkflow };

Memory Architecture with Valkey

// src/memory/config.ts
import { ValkeyMemory } from '@mastra/valkey';

export const createMemory = (userId: string) => new ValkeyMemory({
  url: process.env.VALKEY_URL,
  sessionId: `session:${userId}`,
  lastMessages: 20,
  threads: true,
  // Long-term memory: store key facts permanently
  storageOptions: {
    persistKey: `memory:${userId}:facts`,
    ttl: 86400 * 90,  // 90-day TTL
  },
});

// Memory usage in agent
async function chatWithMemory(userId: string, message: string) {
  const memory = createMemory(userId);
  const agent = new Agent({
    name: 'memory-agent',
    model: openai('gpt-5.6-luna'),
    memory,
    instructions: 'Use conversation history to provide contextual responses.',
  });

  // Agent automatically loads previous context from Valkey
  const response = await agent.generate(message, {
    sessionId: `session:${userId}`,
  });

  return response.text;
}

Performance Benchmarks

Production Reality Check

Rate-limit handling: Valkey handles 100K+ operations per second. For agent workloads, this is never the bottleneck. LLM API rate limits are the constraint. Implement per-user rate limiting with Mastra middleware. Memory management: Valkey stores conversation history in memory with optional disk persistence. For 10K active users with 20-message windows, total memory is approximately 200MB. Failure recovery: If Valkey goes down, Mastra falls back to in-memory session state. Conversations work but context is lost on restart. Always configure Valkey persistence (AOF or RDB snapshots).

By <a href="https://x.com/deeepakbagada" rel="nofollow noopener noreferrer">Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last tested: August 2026 with Mastra 1.0, TypeScript 5.6, Valkey 8.0, and Node v22.

Related Architecture & Implementation Resources

• Explore more production agent architectures in the Daily AI World AI Workflows Directory.
• Discover compatible tool interfaces in the Model Context Protocol (MCP) Directory.
• Track breaking model benchmarks and unit economics on Latest AI News.