Mastra Framework Vollständiger Leitfaden: Das AI Agent Power-Tool für TypeScript-Entwickler

---

title: Mastra Framework Vollständiger Leitfaden: Das AI Agent Power-Tool für TypeScript-Entwickler date: 2026-04-01 authors: [kevinpeng] slug: mastra-typescript-ai-agent-framework-2026-de categories: - KI-Assistenten tags: - Mastra - TypeScript - AI Agent - Open-Source-Framework - Entwickler-Tools cover: https://res.makeronsite.com/freeaitool.com/052-mastra-typescript-ai-agent-framework-2026-cover.webp description: Mastra ist das angesagteste TypeScript AI Agent Framework 2026, mit Workflows, Speicher, RAG, Evaluierung und Tracing. Dieser Leitfaden behandelt Installation, Kernkonzepte, Praxisbeispiele und Produktions-Deployment. lang: de

---

Warum Mastra wählen?

Wenn Sie ein TypeScript/JavaScript-Entwickler sind und in der KI-Anwendungsentwicklung die gleiche Produktivität wie Python-Entwickler erreichen möchten, ist Mastra das Framework, das für Sie gebaut wurde.

Mastra ist ein Open-Source-TypeScript-natives AI-Agent-Framework, unterstützt von Y Combinator, speziell für Web-Entwickler konzipiert. Es bietet alle Grundbausteine, die zum Erstellen, Testen und Bereitstellen von KI-Anwendungen erforderlich sind, und ermöglicht Ihnen den schnellen Weg von der Idee zur Produktion.

Kernvorteile

• TypeScript-Nativ: Vollständige Typunterstützung und IDE-IntelliSense
• Produktionsbereit: Integrierte Workflows, Speicher, RAG, Evaluierung und Tracing
• Entwicklererfahrung: Interaktiver Playground und Echtzeit-Debugging
• Open Source und kostenlos: MIT-Lizenz, community-getrieben

Schnellstart

Mastra installieren

# Neues Projekt erstellen
npx create-mastra@latest my-ai-app

# Projektverzeichnis wechseln
cd my-ai-app

# Abhängigkeiten installieren
npm install

Projektstruktur

my-ai-app/
├── src/
│   ├── mastra/
│   │   ├── agents/          # Agent-Definitionen
│   │   ├── tools/           # Benutzerdefinierte Tools
│   │   ├── workflows/       # Workflows
│   │   └── index.ts         # Haupteinstieg
│   └── index.ts
├── package.json
└── mastra.config.ts

Kernkonzepte

1. Einen Agent erstellen

Agenten sind der zentrale Baustein von Mastra. Jeder Agent hat eine bestimmte Rolle, Tools und Speicher.

// src/mastra/agents/customer-support.ts
import { Agent } from '@mastra/core/agent';

export const customerSupportAgent = new Agent({
  name: 'Customer Support Agent',
  instructions: `
    Sie sind ein professioneller Kundensupport-Assistent, zuständig für die Beantwortung von Benutzerfragen zu Produkten.
    - Freundlichen und professionellen Ton beibehalten
    - Genaue Informationen bereitstellen
    - Wenn Sie die Antwort nicht wissen, ehrlich sagen und Kontakt zum menschlichen Support vorschlagen
  `,
  model: {
    provider: 'ANTHROPIC',
    name: 'claude-sonnet-4-20250514',
  },
});

2. Benutzerdefinierte Tools erstellen

Tools ermöglichen Agenten, konkrete Aktionen auszuführen, wie Datenbankabfragen oder API-Aufrufe.

// src/mastra/tools/order-lookup.ts
import { createTool } from '@mastra/core/tools';
import { z } from 'zod';

export const orderLookupTool = createTool({
  id: 'order-lookup',
  description: 'Bestellstatus nach Bestellnummer abfragen',
  inputSchema: z.object({
    orderId: z.string().describe('Bestellnummer'),
  }),
  execute: async ({ context }) => {
    const { orderId } = context;

    // Datenbankabfrage simulieren
    const order = await db.orders.findUnique({
      where: { id: orderId },
    });

    return {
      status: order?.status || 'not_found',
      items: order?.items || [],
      total: order?.total || 0,
    };
  },
});

3. Tools an einen Agent binden

// src/mastra/agents/customer-support.ts
import { customerSupportAgent } from './customer-support';
import { orderLookupTool } from '../tools/order-lookup';

// Tools hinzufügen
customerSupportAgent.addTools([orderLookupTool]);

4. Workflows erstellen

Workflows ermöglichen es, mehrere Agenten und Tools zu orchestrieren, um komplexe Geschäftsprozesse zu implementieren.

// src/mastra/workflows/order-processing.ts
import { Workflow } from '@mastra/core/workflows';
import { agentStep } from '@mastra/core/step';

export const orderProcessingWorkflow = new Workflow({
  name: 'order-processing',
  triggerSchema: z.object({
    orderId: z.string(),
    customerEmail: z.string().email(),
  }),
});

// Schritte definieren
const checkOrder = agentStep({
  agent: customerSupportAgent,
  outputSchema: z.object({
    status: z.string(),
    canRefund: z.boolean(),
  }),
});

const sendEmail = agentStep({
  agent: emailAgent,
  outputSchema: z.object({
    sent: z.boolean(),
  }),
});

// Ablauf orchestrieren
orderProcessingWorkflow
  .step(checkOrder)
  .then(sendEmail, {
    when: { ref: checkOrder, path: 'canRefund', eq: true },
  });

Praxisbeispiel: Kundenservice-Bot erstellen

Erstellen wir einen vollständigen Kundenservice-Bot, der Bestellanfragen, Rückgabeersuchen und Produktberatung bearbeiten kann.

Vollständiger Code

// src/mastra/index.ts
import { Mastra } from '@mastra/core/mastra';
import { customerSupportAgent } from './agents/customer-support';
import { orderLookupTool } from './tools/order-lookup';
import { refundTool } from './tools/refund';
import { orderProcessingWorkflow } from './workflows/order-processing';

export const mastra = new Mastra({
  agents: {
    'customer-support': customerSupportAgent,
  },
  tools: {
    'order-lookup': orderLookupTool,
    'refund': refundTool,
  },
  workflows: {
    'order-processing': orderProcessingWorkflow,
  },
});

Entwicklungsserver starten

# Mastra-Entwicklungsserver starten (inklusive Playground)
npx mastra dev

Besuchen Sie http://localhost:4111, um den interaktiven Playground zu öffnen und Ihre Agenten in Echtzeit zu testen.

Agent aufrufen

// src/index.ts
import { mastra } from './mastra';

async function main() {
  const agent = mastra.getAgent('customer-support');

  const response = await agent.generate(
    'Meine Bestellnummer ist ORD-12345, bitte prüfen Sie den Status für mich'
  );

  console.log(response.text);
}

main();

Erweiterte Funktionen

Speichersystem

Mastra hat integrierten Speicher, der Agenten ermöglicht, Gesprächsverläufe zu speichern.

import { Memory } from '@mastra/memory';

const memory = new Memory({
  storage: {
    type: 'postgres',
    connectionString: process.env.DATABASE_URL,
  },
});

const agent = new Agent({
  name: 'Support Agent',
  memory,
  // ...weitere Konfiguration
});

RAG (Retrieval-Augmented Generation)

import { RAG } from '@mastra/rag';

const rag = new RAG({
  vectorStore: {
    type: 'pinecone',
    apiKey: process.env.PINECONE_API_KEY,
  },
});

// Dokumente indizieren
await rag.index({
  documents: ['./docs/product-manual.pdf'],
  indexName: 'product-knowledge',
});

// In einem Agent verwenden
const agent = new Agent({
  name: 'Product Expert',
  rag: {
    indexes: ['product-knowledge'],
  },
});

Evaluierung und Tracing

import { Eval } from '@mastra/evals';

const eval = new Eval({
  name: 'response-quality',
  criteria: [
    { name: 'accuracy', weight: 0.4 },
    { name: 'helpfulness', weight: 0.3 },
    { name: 'tone', weight: 0.3 },
  ],
});

# Evaluierung durchführen
const results = await eval.evaluate(agent, testCases);
console.log(results.summary);

Produktions-Deployment

Deployment auf Vercel

# Vercel CLI installieren
npm i -g vercel

# Deployen
vercel deploy --prod

Deployment auf Docker

# Dockerfile
FROM node:20-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

EXPOSE 3000
CMD ["npm", "start"]

# Bauen und ausführen
docker build -t my-mastra-app .
docker run -p 3000:3000 my-mastra-app

Tipps zur Leistungsoptimierung

1. Streaming-Antworten verwenden: Bei langer Textgenerierung Streaming aktivieren, um die Benutzererfahrung zu verbessern
2. Tool-Ergebnisse cachen: Für häufig aufgerufene Tools Ergebniscaching implementieren
3. Batch-Verarbeitung: Für mehrere ähnliche Anfragen Batch-API-Aufrufe verwenden
4. Latenz überwachen: Mastras integriertes Tracing nutzen, um die Dauer jedes Schritts zu überwachen

Vergleich mit anderen Frameworks

Merkmal	Mastra	LangChain.js	Vercel AI SDK
TypeScript-Nativ	✅	⚠️	✅
Integrierte Workflows	✅	✅	❌
Interaktiver Playground	✅	❌	❌
Speichersystem	✅	✅	⚠️
RAG-Unterstützung	✅	✅	❌
Evaluierungs-Tools	✅	⚠️	❌
Lernkurve	Mittel	Steil	Flach

Zusammenfassung

Mastra ist eine der besten Wahlmöglichkeiten für TypeScript-Entwickler, die in die AI-Agent-Entwicklung einsteigen. Es bietet:

• 🎯 Entwicklerfreundliche API: Typsicher, vollständige IntelliSense-Unterstützung
• 🔧 Umfangreiche integrierte Funktionen: Workflows, Speicher, RAG, Evaluierung aus einer Hand
• 🚀 Produktionsbereit: Vollständige Toolchain von der Entwicklung bis zum Deployment
• 📚 Ausgezeichnete Dokumentation: Detaillierte Tutorials und Beispiele

Wenn Sie bereits im TypeScript-Ökosystem arbeiten und schnell KI-Anwendungen erstellen möchten, ist Mastra einen Versuch wert.

Ressourcen

• Mastra Offizielle Dokumentation
• GitHub-Repository
• Mastra Playground
• Beispielprojekte
• Community Discord

---

Empfohlene Lektüre:

• LangGraph Multi-Agenten-Orchestrierungs-Leitfaden
• Google ADK Agent-Entwicklungs-Toolkit
• PydanticAI Framework Vollständiger Leitfaden