Mastra - TypeScript AIエージェントフレームワーク

import { Agent } from "@mastra/core/agent";
import { openai } from "@ai-sdk/openai";

// 基本的なエージェント定義
export const weatherAgent = new Agent({
  name: "weather-agent",
  instructions: `
    あなたは天気情報を提供するアシスタントです。
    ユーザーの質問に親切に答えてください。
    データがない場合は「わかりません」と正直に答えてください。
  `,
  model: openai("gpt-4o-mini"),
});

// エージェントの実行
const response = await weatherAgent.generate("東京の天気は？");
console.log(response.text);

import { Agent } from "@mastra/core/agent";
import { createTool } from "@mastra/core/tools";
import { z } from "zod";

// ツール定義
const searchTool = createTool({
  id: "search",
  description: "Web検索を実行します",
  inputSchema: z.object({
    query: z.string().describe("検索クエリ"),
  }),
  execute: async ({ query }) => {
    // 検索ロジック
    return `「${query}」の検索結果: ...`;
  },
});

const calculatorTool = createTool({
  id: "calculator",
  description: "数式を計算します",
  inputSchema: z.object({
    expression: z.string().describe("計算式"),
  }),
  execute: async ({ expression }) => {
    return String(eval(expression));
  },
});

// ツール付きエージェント
export const assistantAgent = new Agent({
  name: "assistant",
  instructions: "あなたは多機能アシスタントです。",
  model: openai("gpt-4o"),
  tools: [searchTool, calculatorTool],
});

// 実行（エージェントが自動でツールを選択）
const result = await assistantAgent.generate(
  "100 * 25 を計算して、その結果についてWeb検索して"
);

import { Workflow, Step } from "@mastra/core/workflows";
import { z } from "zod";

// ワークフロー定義
const blogWritingWorkflow = new Workflow({
  name: "blog-writing",
  triggerSchema: z.object({
    topic: z.string(),
  }),
});

// ステップ1: リサーチ
const researchStep = new Step({
  id: "research",
  execute: async ({ context }) => {
    const { topic } = context.triggerData;
    // リサーチエージェントを呼び出し
    const research = await researchAgent.generate(
      `「${topic}」について詳しく調査してください`
    );
    return { research: research.text };
  },
});

// ステップ2: 執筆
const writeStep = new Step({
  id: "write",
  execute: async ({ context }) => {
    const { research } = context.getStepResult("research");
    const article = await writerAgent.generate(
      `以下の調査結果を元にブログ記事を書いてください:\n${research}`
    );
    return { article: article.text };
  },
});

// ステップ3: 編集
const editStep = new Step({
  id: "edit",
  execute: async ({ context }) => {
    const { article } = context.getStepResult("write");
    const edited = await editorAgent.generate(
      `以下の記事を校正してください:\n${article}`
    );
    return { finalArticle: edited.text };
  },
});

// ワークフロー構築
blogWritingWorkflow
  .step(researchStep)
  .then(writeStep)
  .then(editStep)
  .commit();

// 実行
const result = await blogWritingWorkflow.execute({
  triggerData: { topic: "2026年のAIエージェント動向" },
});

import { RAG } from "@mastra/rag";
import { PgVector } from "@mastra/pg";

// ベクトルストア設定
const vectorStore = new PgVector({
  connectionString: process.env.DATABASE_URL,
});

// RAGパイプライン
const rag = new RAG({
  vectorStore,
  embedModel: openai.embedding("text-embedding-3-small"),
});

// ドキュメントの埋め込み
await rag.embed({
  documents: [
    { id: "doc1", content: "Mastraは TypeScript製のAIエージェントフレームワークです..." },
    { id: "doc2", content: "Gatsbyチームによって開発されました..." },
  ],
  chunkSize: 500,
  chunkOverlap: 50,
});

// RAG付きエージェント
const ragAgent = new Agent({
  name: "rag-assistant",
  instructions: "提供されたコンテキストを元に回答してください。",
  model: openai("gpt-4o"),
});

// クエリ実行
const context = await rag.retrieve({
  query: "Mastraの開発元は？",
  topK: 3,
});

const response = await ragAgent.generate(
  `コンテキスト: ${context.map(c => c.content).join("\n")}\n\n質問: Mastraの開発元は？`
);

import { Agent } from "@mastra/core/agent";
import { Memory } from "@mastra/memory";
import { PostgresStore } from "@mastra/pg";

// メモリストア設定
const memoryStore = new PostgresStore({
  connectionString: process.env.DATABASE_URL,
});

// メモリ付きエージェント
const conversationalAgent = new Agent({
  name: "conversational",
  instructions: "あなたは親切なアシスタントです。会話履歴を覚えています。",
  model: openai("gpt-4o"),
  memory: new Memory({
    store: memoryStore,
    // ワーキングメモリ（短期記憶）
    workingMemory: {
      enabled: true,
      maxMessages: 10,
    },
    // セマンティックメモリ（長期記憶）
    semanticMemory: {
      enabled: true,
      embedModel: openai.embedding("text-embedding-3-small"),
    },
  }),
});

// セッション管理
const sessionId = "user-123";

// 会話1
await conversationalAgent.generate("私の名前は田中です", { sessionId });

// 会話2（前の会話を覚えている）
const response = await conversationalAgent.generate(
  "私の名前を覚えていますか？",
  { sessionId }
);
// → "はい、田中さんですね"

import { MCPServer } from "@mastra/mcp";
import { myAgent } from "./agents";

// MCPサーバーの作成
const server = new MCPServer({
  name: "my-agent-server",
  version: "1.0.0",
});

// エージェントをMCPリソースとして公開
server.addAgent(myAgent);

// ツールをMCPツールとして公開
server.addTool({
  name: "search",
  description: "Web検索",
  inputSchema: {
    type: "object",
    properties: {
      query: { type: "string" },
    },
  },
  handler: async (input) => {
    return await searchTool.execute(input);
  },
});

// サーバー起動
server.listen({ port: 3000 });

// Claude Desktop、Cursor等からMCP経由でアクセス可能に