@mastra/mcp-docs-server 0.13.21 → 0.13.22-alpha.0

package/.docs/raw/reference/client-js/workflows.mdx

@@ -44,10 +44,9 @@ const details = await workflow.details();
 Start a workflow run with inputData and await full run results:
 
 ```typescript
-const run = await workflow.createRun();
+const run = await workflow.createRunAsync();
 
-const result = await workflow.startAsync({
-  runId: run.runId,
+const result = await run.startAsync({
   inputData: {
     city: "New York",
   },
@@ -59,10 +58,9 @@ const result = await workflow.startAsync({
 Resume a suspended workflow step and await full run result:
 
 ```typescript
-const run = await workflow.createRun();
+const run = await workflow.createRunAsync();
 
-const result = await workflow.resumeAsync({
-  runId: run.runId,
+const result = await run.resumeAsync({
   step: "step-id",
   resumeData: { key: "value" },
 });
@@ -76,14 +74,13 @@ Watch workflow transitions:
 try {
   const workflow = mastraClient.getWorkflow("testWorkflow");
 
-  const run = await workflow.createRun();
+  const run = await workflow.createRunAsync();
 
-  workflow.watch({ runId: run.runId }, (record) => {
+  run.watch((record) => {
     console.log(record);
   });
 
-  const result = await workflow.start({
-    runId: run.runId,
+  const result = await run.start({
     inputData: {
       city: "New York",
     },
@@ -101,14 +98,13 @@ Resume workflow run and watch workflow step transitions:
 try {
   const workflow = mastraClient.getWorkflow("testWorkflow");
 
-  const run = await workflow.createRun({ runId: prevRunId });
+  const run = await workflow.createRunAsync({ runId: prevRunId });
 
-  workflow.watch({ runId: run.runId }, (record) => {
+  run.watch((record) => {
     console.log(record);
   });
 
-  workflow.resume({
-    runId: run.runId,
+  run.resume({
     step: "step-id",
     resumeData: { key: "value" },
   });
@@ -117,6 +113,30 @@ try {
 }
 ```
 
+### Stream Workflow
+
+Stream workflow execution for real-time updates:
+
+```typescript
+try {
+  const workflow = mastraClient.getWorkflow("testWorkflow");
+
+  const run = await workflow.createRunAsync();
+
+  const stream = await run.stream({
+    inputData: {
+      city: 'New York',
+    },
+  });
+
+  for await (const chunk of stream) {
+    console.log(JSON.stringify(chunk, null, 2));
+  }
+} catch (e) {
+  console.error('Workflow error:', e);
+}
+```
+
 ### Get Workflow Run result
 
 Get the result of a workflow run:
@@ -125,11 +145,10 @@ Get the result of a workflow run:
 try  {
   const workflow = mastraClient.getWorkflow("testWorkflow");
 
-  const run = await workflow.createRun();
+  const run = await workflow.createRunAsync();
 
   // start the workflow run
-  const startResult = await workflow.start({
-    runId: run.runId,
+  const startResult = await run.start({
     inputData: {
       city: "New York",
     },

package/.docs/raw/reference/core/mastra-class.mdx

@@ -1,6 +1,6 @@
 ---
-title: "Mastra Core"
-description: Documentation for the Mastra Class, the core entry point for managing agents, workflows, MCP servers, and server endpoints.
+title: "Reference: Mastra Class | Core | Mastra Docs"
+description: "Documentation for the `Mastra` class in Mastra, the core entry point for managing agents, workflows, MCP servers, and server endpoints."
 ---
 
 # Mastra Class

package/.docs/raw/reference/memory/Memory.mdx

@@ -1,305 +1,157 @@
-# Memory Class Reference
+---
+title: "Reference: Memory Class | Memory | Mastra Docs"
+description: "Documentation for the `Memory` class in Mastra, which provides a robust system for managing conversation history and thread-based message storage."
+---
 
-The `Memory` class provides a robust system for managing conversation history and thread-based message storage in Mastra. It enables persistent storage of conversations, semantic search capabilities, and efficient message retrieval. You must configure a storage provider for conversation history, and if you enable semantic recall you will also need to provide a vector store and embedder.
-
-## Basic Usage
-
-```typescript copy showLineNumbers
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-
-const agent = new Agent({
-  memory: new Memory(),
-  ...otherOptions,
-});
-```
-
-## Custom Configuration
-
-```typescript copy showLineNumbers
-import { Memory } from "@mastra/memory";
-import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
-import { Agent } from "@mastra/core/agent";
-
-const memory = new Memory({
-  // Optional storage configuration - libsql will be used by default
-  storage: new LibSQLStore({
-    url: "file:./memory.db",
-  }),
-
-  // Optional vector database for semantic search
-  vector: new LibSQLVector({
-    url: "file:./vector.db",
-  }),
-
-  // Memory configuration options
-  options: {
-    // Number of recent messages to include
-    lastMessages: 20,
-
-    // Semantic search configuration
-    semanticRecall: {
-      topK: 3, // Number of similar messages to retrieve
-      messageRange: {
-        // Messages to include around each result
-        before: 2,
-        after: 1,
-      },
-    },
-
-    // Working memory configuration
-    workingMemory: {
-      enabled: true,
-      template: `
-# User
-- First Name:
-- Last Name:
-`,
-    },
-
-    // Thread configuration
-    threads: {
-      generateTitle: true, // Enable title generation using agent's model
-      // Or use a different model for title generation
-      // generateTitle: {
-      //   model: openai("gpt-4.1-nano"), // Use cheaper model for titles
-      //   instructions: "Generate a concise title based on the initial user message.", // Custom instructions for title
-      // },
-    },
-  },
-});
-
-const agent = new Agent({
-  memory,
-  ...otherOptions,
-});
-```
-
-### Working Memory
-
-The working memory feature allows agents to maintain persistent information across conversations. When enabled, the Memory class automatically manages working memory updates using a dedicated tool call.
-
-Example configuration:
-
-```typescript copy showLineNumbers
-const memory = new Memory({
-  options: {
-    workingMemory: {
-      enabled: true,
-      template: "# User\n- **First Name**:\n- **Last Name**:",
-    },
-  },
-});
-```
-
-If no template is provided, the Memory class uses a default template that includes fields for user details, preferences, goals, and other contextual information in Markdown format. See the [Working Memory guide](/docs/memory/working-memory.mdx#designing-effective-templates) for detailed usage examples and best practices.
-
-### Thread Title Generation
-
-The `generateTitle` feature automatically creates meaningful titles for conversation threads based on the user's first message. This helps organize and identify conversations in your application.
-
-#### Basic Usage
-
-```typescript copy showLineNumbers
-const memory = new Memory({
-  options: {
-    threads: {
-      generateTitle: true, // Use the agent's model for title generation
-    },
-  },
-});
-```
-
-#### Cost Optimization with Custom Models and Instructions
-
-You can specify a different (typically cheaper) model and custom instructions for title generation while using a high-quality model for the main conversation:
-
-```typescript copy showLineNumbers
-import { openai } from "@ai-sdk/openai";
-
-const memory = new Memory({
-  options: {
-    threads: {
-      generateTitle: {
-        model: openai("gpt-4.1-nano"), // Cheaper model for titles
-        instructions: "Generate a concise, friendly title based on the initial user message.", // Custom title instructions
-      },
-    },
-  },
-});
-
-const agent = new Agent({
-  model: openai("gpt-4o"), // High-quality model for main conversation
-  memory,
-});
-```
-
-#### Dynamic Model Selection and Instructions
+# Memory Class
 
-You can also use a function to dynamically determine the model and instructions based on runtime context:
-
-```typescript copy showLineNumbers
-const memory = new Memory({
-  options: {
-    threads: {
-      generateTitle: {
-        model: (ctx: RuntimeContext) => {
-          // Use different models based on context
-          const userTier = ctx.get("userTier");
-          return userTier === "premium" 
-            ? openai("gpt-4.1")
-            : openai("gpt-4.1-nano");
-        },
-        instructions: (ctx: RuntimeContext) => {
-          const language = ctx.get("userLanguage") || "English";
-          return `Generate a concise, engaging title in ${language} based on the user's first message.`;
-        },
-      },
-    },
-  },
-});
-```
-### embedder
-
-An embedding model is required if `semanticRecall` is enabled.
-
-One option is to use `@mastra/fastembed`, which provides an on-device/local embedding model using [FastEmbed](https://github.com/Anush008/fastembed-js). This model runs locally and does not require API keys or network requests.
-
-To use it, first install the package:
-
-```bash npm2yarn copy
-npm install @mastra/fastembed
-```
+The `Memory` class provides a robust system for managing conversation history and thread-based message storage in Mastra. It enables persistent storage of conversations, semantic search capabilities, and efficient message retrieval. You must configure a storage provider for conversation history, and if you enable semantic recall you will also need to provide a vector store and embedder.
 
-Then, configure it in your `Memory` instance:
+## Usage example
 
-```typescript {2,7}
+```typescript filename="src/mastra/agents/test-agent.ts" showLineNumbers copy
 import { Memory } from "@mastra/memory";
-import { fastembed } from "@mastra/fastembed";
 import { Agent } from "@mastra/core/agent";
-
-const agent = new Agent({
-  memory: new Memory({
-    embedder: fastembed,
-    // ... other memory config
-  }),
-});
-```
-
-Note that, depending on where you're deploying your project, your project may not deploy due to FastEmbeds large internal dependencies.
-
-Alternatively, you can use an API-based embedder like OpenAI (which doesn't have this problem):
-
-```typescript {2,7}
-import { Memory } from "@mastra/memory";
 import { openai } from "@ai-sdk/openai";
-import { Agent } from "@mastra/core/agent";
 
-const agent = new Agent({
+export const agent = new Agent({
+  name: "test-agent",
+  instructions: "You are an agent with memory.",
+  model: openai("gpt-4o"),
   memory: new Memory({
-    embedder: openai.embedding("text-embedding-3-small"),
-  }),
+    options: {
+      workingMemory: {
+        enabled: true
+      }
+    }
+  })
 });
 ```
 
-Mastra supports many embedding models through the [Vercel AI SDK](https://sdk.vercel.ai/docs/ai-sdk-core/embeddings), including options from OpenAI, Google, Mistral, and Cohere.
+> To enable `workingMemory` on an agent, you’ll need a storage provider configured on your main Mastra instance. See [Mastra class](../core/mastra-class.mdx) for more information.
 
-## Parameters
+## Constructor parameters
 
 <PropertiesTable
   content={[
     {
       name: "storage",
       type: "MastraStorage",
-      description: "Storage implementation for persisting memory data",
+      description: "Storage implementation for persisting memory data. Defaults to `new DefaultStorage({ config: { url: \"file:memory.db\" } })` if not provided.",
       isOptional: true,
     },
     {
       name: "vector",
-      type: "MastraVector",
-      description: "Vector store for semantic search capabilities",
+      type: "MastraVector | false",
+      description: "Vector store for semantic search capabilities. Set to `false` to disable vector operations.",
       isOptional: true,
     },
     {
       name: "embedder",
-      type: "EmbeddingModel",
-      description:
-        "Embedder instance for vector embeddings. Required when semantic recall is enabled",
+      type: "EmbeddingModel<string> | EmbeddingModelV2<string>",
+      description: "Embedder instance for vector embeddings. Required when semantic recall is enabled.",
       isOptional: true,
     },
     {
       name: "options",
       type: "MemoryConfig",
-      description: "General memory configuration options",
+      description: "Memory configuration options.",
+      isOptional: true,
+    },
+    {
+      name: "processors",
+      type: "MemoryProcessor[]",
+      description: "Array of memory processors that can filter or transform messages before they're sent to the LLM.",
       isOptional: true,
     },
   ]}
 />
 
-### options
+### Options parameters
 
 <PropertiesTable
   content={[
     {
       name: "lastMessages",
       type: "number | false",
-      description:
-        "Number of most recent messages to retrieve. Set to false to disable.",
+      description: "Number of most recent messages to retrieve. Set to false to disable.",
       isOptional: true,
       defaultValue: "10",
     },
     {
       name: "semanticRecall",
-      type: "boolean | SemanticRecallConfig",
-      description:
-        "Enable semantic search in message history. Automatically enabled when vector store is provided.",
+      type: "boolean | { topK: number; messageRange: number | { before: number; after: number }; scope?: 'thread' | 'resource' }",
+      description: "Enable semantic search in message history. Can be a boolean or an object with configuration options. When enabled, requires both vector store and embedder to be configured.",
       isOptional: true,
       defaultValue: "false",
     },
-    {
-      name: "topK",
-      type: "number",
-      description:
-        "Number of similar messages to retrieve when using semantic search",
-      isOptional: true,
-      defaultValue: "2",
-    },
-    {
-      name: "messageRange",
-      type: "number | { before: number; after: number }",
-      description:
-        "Range of messages to include around semantic search results",
-      isOptional: true,
-      defaultValue: "2",
-    },
-    {
-      name: "scope",
-      type: "'thread' | 'resource'",
-      description:
-        "Scope for semantic search. 'thread' searches within the current thread only (default). 'resource' searches across all threads for a given resourceId, allowing agents to recall information from any of the user's past conversations. The 'resource' scope is currently supported by LibSQL, Postgres, and Upstash storage adapters.",
-      isOptional: true,
-      defaultValue: "'thread'",
-    },
     {
       name: "workingMemory",
-      type: "{ enabled: boolean; template?: string }",
-      description:
-        "Configuration for working memory feature that allows persistent storage of user information across conversations. Working memory uses Markdown format to structure and store continuously relevant information.",
+      type: "WorkingMemory",
+      description: "Configuration for working memory feature. Can be `{ enabled: boolean; template?: string; schema?: ZodObject<any> | JSONSchema7; scope?: 'thread' | 'resource' }` or `{ enabled: boolean }` to disable.",
       isOptional: true,
-      defaultValue:
-        "{ enabled: false, template: '# User Information\\n- **First Name**:\\n- **Last Name**:\\n...' }",
+      defaultValue: "{ enabled: false, template: '# User Information\\n- **First Name**:\\n- **Last Name**:\\n...' }",
     },
     {
       name: "threads",
-      type: "{ generateTitle?: boolean | { model: MastraLanguageModel | ((ctx: RuntimeContext) => MastraLanguageModel | Promise<MastraLanguageModel>), instructions?: string | ((ctx: RuntimeContext) => string | Promise<string>) } }",
-      description:
-        "Settings related to memory thread creation. `generateTitle` controls automatic thread title generation from the user's first message. Can be a boolean to enable/disable using the agent's model, or an object specifying a custom model or custom instructions for title generation (useful for cost optimization or title customization). Example: { generateTitle: { model: openai('gpt-4.1-nano'), instructions: 'Concise title based on the initial user message.' } }",
+      type: "{ generateTitle?: boolean | { model: DynamicArgument<MastraLanguageModel>; instructions?: DynamicArgument<string> } }",
+      description: "Settings related to memory thread creation. `generateTitle` controls automatic thread title generation from the user's first message. Can be a boolean or an object with custom model and instructions.",
       isOptional: true,
       defaultValue: "{ generateTitle: false }",
     },
   ]}
 />
 
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "memory",
+      type: "Memory",
+      description: "A new Memory instance with the specified configuration.",
+    },
+  ]}
+/>
+
+
+## Extended usage example
+
+```typescript filename="src/mastra/agents/test-agent.ts" showLineNumbers copy
+import { Memory } from "@mastra/memory";
+import { Agent } from "@mastra/core/agent";
+import { openai } from "@ai-sdk/openai";
+import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
+
+export const agent = new Agent({
+  name: "test-agent",
+  instructions: "You are an agent with memory.",
+  model: openai("gpt-4o"),
+  memory: new Memory({
+    storage: new LibSQLStore({
+      url: "file:./working-memory.db"
+    }),
+    vector: new LibSQLVector({
+      connectionUrl: "file:./vector-memory.db"
+    }),
+    options: {
+      lastMessages: 10,
+      semanticRecall: {
+        topK: 3,
+        messageRange: 2,
+        scope: 'resource'
+      },
+      workingMemory: {
+        enabled: true
+      },
+      threads: {
+        generateTitle: true
+      }
+    }
+  })
+});
+```
+
 ### Related
 
 - [Getting Started with Memory](/docs/memory/overview.mdx)

package/.docs/raw/reference/memory/createThread.mdx

@@ -1,23 +1,16 @@
-# createThread
+---
+title: "Reference: Memory.createThread() | Memory | Mastra Docs"
+description: "Documentation for the `Memory.createThread()` method in Mastra, which creates a new conversation thread in the memory system."
+---
 
-Creates a new conversation thread in the memory system. Each thread represents a distinct conversation or context and can contain multiple messages.
+# Memory.createThread()
 
-## Usage Example
+The `.createThread()` method creates a new conversation thread in the memory system. Each thread represents a distinct conversation or context and can contain multiple messages.
 
-```typescript
-import { Memory } from "@mastra/memory";
+## Usage Example
 
-const memory = new Memory({
-  /* config */
-});
-const thread = await memory.createThread({
-  resourceId: "user-123",
-  title: "Support Conversation",
-  metadata: {
-    category: "support",
-    priority: "high",
-  },
-});
+```typescript copy
+await memory?.createThread({ resourceId: "user-123" });
 ```
 
 ## Parameters
@@ -90,6 +83,33 @@ const thread = await memory.createThread({
   ]}
 />
 
+## Extended usage example
+
+```typescript filename="src/test-memory.ts" showLineNumbers copy
+import { mastra } from "./mastra";
+
+const agent = mastra.getAgent("agent");
+const memory = await agent.getMemory();
+
+const thread = await memory?.createThread({
+  resourceId: "user-123",
+  title: "Memory Test Thread",
+  metadata: {
+    source: "test-script",
+    purpose: "memory-testing"
+  }
+});
+
+const response = await agent.generate("message for agent", {
+  memory: {
+    thread: thread!.id,
+    resource: thread!.resourceId
+  }
+});
+
+console.log(response.text);
+```
+
 ### Related
 
 - [Memory Class Reference](/reference/memory/Memory.mdx)