@mastra/mcp-docs-server 1.0.0-beta.7 → 1.0.0-beta.9

package/.docs/raw/reference/core/listMemory.mdx

@@ -0,0 +1,70 @@
+---
+title: "Reference: Mastra.listMemory() | Core"
+description: "Documentation for the `Mastra.listMemory()` method in Mastra, which returns all registered memory instances."
+---
+
+# Mastra.listMemory()
+
+The `.listMemory()` method returns all memory instances registered with the Mastra instance.
+
+## Usage example
+
+```typescript copy
+const memoryInstances = mastra.listMemory();
+
+for (const [key, memory] of Object.entries(memoryInstances)) {
+  console.log(`Memory "${key}": ${memory.id}`);
+}
+```
+
+## Parameters
+
+This method takes no parameters.
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "memory",
+      type: "Record<string, MastraMemory>",
+      description:
+        "An object containing all registered memory instances, keyed by their registry keys.",
+    },
+  ]}
+/>
+
+## Example: Checking Registered Memory
+
+```typescript copy
+import { Mastra } from "@mastra/core";
+import { Memory } from "@mastra/memory";
+import { LibSQLStore } from "@mastra/libsql";
+
+const conversationMemory = new Memory({
+  id: "conversation-memory",
+  storage: new LibSQLStore({ url: ":memory:" }),
+});
+
+const analyticsMemory = new Memory({
+  id: "analytics-memory",
+  storage: new LibSQLStore({ url: ":memory:" }),
+});
+
+const mastra = new Mastra({
+  memory: {
+    conversationMemory,
+    analyticsMemory,
+  },
+});
+
+// List all registered memory instances
+const allMemory = mastra.listMemory();
+console.log(Object.keys(allMemory)); // ["conversationMemory", "analyticsMemory"]
+```
+
+## Related
+
+- [Mastra.getMemory()](/reference/v1/core/getMemory)
+- [Memory overview](/docs/v1/memory/overview)
+- [Agent Memory](/docs/v1/agents/agent-memory)

package/.docs/raw/reference/core/listStoredAgents.mdx

@@ -0,0 +1,151 @@
+---
+title: "Reference: Mastra.listStoredAgents() | Core"
+description: "Documentation for the `Mastra.listStoredAgents()` method in Mastra, which retrieves a paginated list of agents from storage."
+---
+
+# Mastra.listStoredAgents()
+
+The `.listStoredAgents()` method retrieves a paginated list of agent configurations from storage. By default, it returns executable `Agent` instances, but can also return raw storage data.
+
+## Usage example
+
+```typescript copy
+// Get Agent instances from storage
+const { agents, total, hasMore } = await mastra.listStoredAgents();
+
+for (const agent of agents) {
+  console.log(agent.id, agent.name);
+  // Each agent is ready to use
+  // const response = await agent.generate({ messages: "Hello!" });
+}
+```
+
+```typescript copy
+// Get paginated results with raw storage data
+const result = await mastra.listStoredAgents({
+  page: 0,
+  perPage: 10,
+  raw: true,
+});
+
+console.log(`Showing ${result.agents.length} of ${result.total} agents`);
+console.log(`Has more: ${result.hasMore}`);
+
+for (const config of result.agents) {
+  console.log(config.id, config.name, config.createdAt);
+}
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "args",
+      type: "object",
+      description:
+        "Optional configuration object for pagination and output format.",
+      isOptional: true,
+    },
+  ]}
+/>
+
+### Args Options
+
+<PropertiesTable
+  content={[
+    {
+      name: "page",
+      type: "number",
+      description: "Zero-indexed page number for pagination.",
+      isOptional: true,
+      defaultValue: "0",
+    },
+    {
+      name: "perPage",
+      type: "number | false",
+      description:
+        "Number of items per page. Set to `false` to fetch all records without pagination.",
+      isOptional: true,
+      defaultValue: "100",
+    },
+    {
+      name: "raw",
+      type: "boolean",
+      description:
+        "When `true`, returns raw `StorageAgentType` objects instead of `Agent` instances.",
+      isOptional: true,
+      defaultValue: "false",
+    },
+  ]}
+/>
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "agents",
+      type: "Agent[] | StorageAgentType[]",
+      description:
+        "Array of `Agent` instances by default, or `StorageAgentType` objects when `raw: true`.",
+    },
+    {
+      name: "total",
+      type: "number",
+      description: "Total number of stored agents across all pages.",
+    },
+    {
+      name: "page",
+      type: "number",
+      description: "Current page number (zero-indexed).",
+    },
+    {
+      name: "perPage",
+      type: "number | false",
+      description: "Number of items per page, or `false` if fetching all.",
+    },
+    {
+      name: "hasMore",
+      type: "boolean",
+      description: "Whether there are more pages available.",
+    },
+  ]}
+/>
+
+## Primitive Resolution
+
+When creating `Agent` instances (default behavior), each stored agent's configuration is resolved against registered primitives:
+
+- **Tools**: Resolved from `tools` registered in Mastra config
+- **Workflows**: Resolved from `workflows` registered in Mastra config
+- **Sub-agents**: Resolved from `agents` registered in Mastra config
+- **Memory**: Resolved from `memory` registered in Mastra config
+- **Scorers**: Resolved from `scorers` registered in Mastra config
+
+If a referenced primitive is not found, a warning is logged but the agent is still created.
+
+## Example: Iterating Through All Stored Agents
+
+```typescript copy
+async function getAllStoredAgents(mastra: Mastra) {
+  const allAgents: Agent[] = [];
+  let page = 0;
+  let hasMore = true;
+
+  while (hasMore) {
+    const result = await mastra.listStoredAgents({ page, perPage: 50 });
+    allAgents.push(...result.agents);
+    hasMore = result.hasMore;
+    page++;
+  }
+
+  return allAgents;
+}
+```
+
+## Related
+
+- [Mastra.getStoredAgentById()](/reference/v1/core/getStoredAgentById)
+- [Storage overview](/docs/v1/server-db/storage)
+- [Agents overview](/docs/v1/agents/overview)

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

@@ -148,5 +148,13 @@ export const mastra = new Mastra({
       isOptional: true,
       defaultValue: "{}",
     },
+    {
+      name: "memory",
+      type: "Record<string, MastraMemory>",
+      description:
+        "Memory instances to register. These can be referenced by stored agents and resolved at runtime. Structured as a key-value pair, with keys being the registry key and values being memory instances.",
+      isOptional: true,
+      defaultValue: "{}",
+    },
   ]}
 />

package/.docs/raw/reference/server/express-adapter.mdx

@@ -5,6 +5,7 @@ description: "API reference for the @mastra/express server adapter."
 
 import Steps from "@site/src/components/Steps";
 import StepItem from "@site/src/components/StepItem";
+import PropertiesTable from "@site/src/components/PropertiesTable";
 
 # Express Adapter
 
@@ -87,6 +88,57 @@ await server.init();
 app.listen(4111);
 ```
 
+## Constructor parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "app",
+      type: "Application",
+      description: "Express app instance",
+      isOptional: false,
+    },
+    {
+      name: "mastra",
+      type: "Mastra",
+      description: "Mastra instance",
+      isOptional: false,
+    },
+    {
+      name: "prefix",
+      type: "string",
+      description: "Route path prefix (e.g., `/api/v2`)",
+      isOptional: true,
+      defaultValue: "''",
+    },
+    {
+      name: "openapiPath",
+      type: "string",
+      description: "Path to serve OpenAPI spec (e.g., `/openapi.json`)",
+      isOptional: true,
+    },
+    {
+      name: "bodyLimitOptions",
+      type: "{ maxSize: number, onError: (err) => unknown }",
+      description: "Request body size limits",
+      isOptional: true,
+    },
+    {
+      name: "streamOptions",
+      type: "{ redact?: boolean }",
+      description: "Stream redaction config. When true, redacts sensitive data from streams.",
+      isOptional: true,
+      defaultValue: "{ redact: true }",
+    },
+    {
+      name: "customRouteAuthConfig",
+      type: "Map<string, boolean>",
+      description: "Per-route auth overrides. Keys are `METHOD:PATH` (e.g., `GET:/api/health`). Value `false` makes route public, `true` requires auth.",
+      isOptional: true,
+    },
+  ]}
+/>
+
 ## Differences from Hono
 
 | Aspect | Express | Hono |

package/.docs/raw/reference/server/hono-adapter.mdx

@@ -5,6 +5,7 @@ description: "API reference for the @mastra/hono server adapter."
 
 import Steps from "@site/src/components/Steps";
 import StepItem from "@site/src/components/StepItem";
+import PropertiesTable from "@site/src/components/PropertiesTable";
 
 # Hono Adapter
 
@@ -77,6 +78,59 @@ await server.init();
 export default app;
 ```
 
+
+## Constructor parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "app",
+      type: "Hono",
+      description: "Hono app instance",
+      isOptional: false,
+    },
+    {
+      name: "mastra",
+      type: "Mastra",
+      description: "Mastra instance",
+      isOptional: false,
+    },
+    {
+      name: "prefix",
+      type: "string",
+      description: "Route path prefix (e.g., `/api/v2`)",
+      isOptional: true,
+      defaultValue: "''",
+    },
+    {
+      name: "openapiPath",
+      type: "string",
+      description: "Path to serve OpenAPI spec (e.g., `/openapi.json`)",
+      isOptional: true,
+    },
+    {
+      name: "bodyLimitOptions",
+      type: "{ maxSize: number, onError: (err) => unknown }",
+      description: "Request body size limits",
+      isOptional: true,
+    },
+    {
+      name: "streamOptions",
+      type: "{ redact?: boolean }",
+      description: "Stream redaction config. When true, redacts sensitive data from streams.",
+      isOptional: true,
+      defaultValue: "{ redact: true }",
+    },
+    {
+      name: "customRouteAuthConfig",
+      type: "Map<string, boolean>",
+      description: "Per-route auth overrides. Keys are `METHOD:PATH` (e.g., `GET:/api/health`). Value `false` makes route public, `true` requires auth.",
+      isOptional: true,
+    },
+  ]}
+/>
+
+
 ## Adding custom routes
 
 Add routes directly to the Hono app:

package/.docs/raw/server-db/custom-api-routes.mdx

@@ -5,11 +5,11 @@ description: "Expose additional HTTP endpoints from your Mastra server."
 
 # Custom API Routes
 
-By default Mastra automatically exposes registered agents and workflows via the server. For additional behavior you can define your own HTTP routes.
+By default, Mastra automatically exposes registered agents and workflows via its server. For additional behavior you can define your own HTTP routes.
 
-Routes are provided with a helper `registerApiRoute` from `@mastra/core/server`. Routes can live in the same file as the `Mastra` instance but separating them helps keep configuration concise.
+Routes are provided with a helper `registerApiRoute()` from `@mastra/core/server`. Routes can live in the same file as the `Mastra` instance but separating them helps keep configuration concise.
 
-```typescript title="src/mastra/index.ts" copy showLineNumbers
+```typescript title="src/mastra/index.ts" copy
 import { Mastra } from "@mastra/core";
 import { registerApiRoute } from "@mastra/core/server";
 
@@ -39,9 +39,9 @@ curl http://localhost:4111/my-custom-route
 
 Each route's handler receives the Hono `Context`. Within the handler you can access the `Mastra` instance to fetch or call agents and workflows.
 
-To add route-specific middleware pass a `middleware` array when calling `registerApiRoute`.
+To add route-specific middleware pass a `middleware` array when calling `registerApiRoute()`.
 
-```typescript title="src/mastra/index.ts" copy showLineNumbers
+```typescript title="src/mastra/index.ts" copy
 import { Mastra } from "@mastra/core";
 import { registerApiRoute } from "@mastra/core/server";
 

package/.docs/raw/server-db/server-adapters.mdx

@@ -3,20 +3,16 @@ title: "Server Adapters | Server & DB"
 description: "Manually configure a Mastra server using Hono or Express adapters."
 ---
 
-import PropertiesTable from "@site/src/components/PropertiesTable";
 import Tabs from "@theme/Tabs";
 import TabItem from "@theme/TabItem";
 
 # Server Adapters
 
-Server adapters let you run Mastra with your own HTTP server instead of using `mastra build`. While `mastra build` generates a standalone server for you, adapters give you full control over the server setup, letting you integrate Mastra into any Node.js application.
+Server adapters let you run Mastra with your own HTTP server instead of the Hono server generated by `mastra build`. They provide more control over the server setup, including custom middleware ordering, authentication, logging, and deployment configuration, while still letting you integrate Mastra into any Node.js application without changing how agents or workflows execute.
 
-Use adapters when you need to:
+## When to use server adapters
 
-- **Integrate Mastra into an existing application** - Add Mastra endpoints to an Express or Hono app you already have running
-- **Control middleware ordering** - Insert your own middleware before or after Mastra's authentication and routing
-- **Deploy to platforms requiring specific server setup** - Some platforms like Cloudflare Workers or custom Docker setups need direct access to the server instance
-- **Use Express instead of Hono** - `mastra build` uses Hono internally, but you may prefer Express for its ecosystem or team familiarity
+Use server adapters when you want Mastra’s endpoints added automatically to an existing application, when you need direct access to the server instance for custom configuration, or when your team prefers using Express instead of the Hono server created by `mastra build`.
 
 :::info
 
@@ -26,81 +22,85 @@ For simple deployments without custom server requirements, use `mastra build` in
 
 ## Available adapters
 
-- **[@mastra/hono](/reference/v1/server/hono-adapter)** - Hono framework adapter
-- **[@mastra/express](/reference/v1/server/express-adapter)** - Express framework adapter
-
-## Basic setup
-
-Both adapters follow the same pattern. The adapter wraps your framework's app instance and registers Mastra's routes and middleware onto it.
-
-1. **Create your framework's app instance** - Initialize Hono or Express as you normally would
-2. **Create a `MastraServer`** - Pass your app and Mastra instance to the adapter
-3. **Call `init()`** - This registers context middleware, authentication, and all API routes
-
-After `init()`, your app has all the Mastra endpoints (`/api/agents`, `/api/workflows`, etc.) and you can add your own routes before or after.
-
-See the [Hono Adapter](/reference/v1/server/hono-adapter) or [Express Adapter](/reference/v1/server/express-adapter) docs for framework-specific setup and code examples.
-
-## Constructor options
-
-Both adapters accept the same options:
-
-<PropertiesTable
-  content={[
-    {
-      name: "app",
-      type: "Hono | Application",
-      description: "Framework app instance",
-      isOptional: false,
-    },
-    {
-      name: "mastra",
-      type: "Mastra",
-      description: "Mastra instance",
-      isOptional: false,
-    },
-    {
-      name: "prefix",
-      type: "string",
-      description: "Route path prefix (e.g., `/api/v2`)",
-      isOptional: true,
-      defaultValue: "''",
-    },
-    {
-      name: "openapiPath",
-      type: "string",
-      description: "Path to serve OpenAPI spec (e.g., `/openapi.json`)",
-      isOptional: true,
-    },
-    {
-      name: "bodyLimitOptions",
-      type: "{ maxSize: number, onError: (err) => unknown }",
-      description: "Request body size limits",
-      isOptional: true,
-    },
-    {
-      name: "streamOptions",
-      type: "{ redact?: boolean }",
-      description: "Stream redaction config. When true, redacts sensitive data from streams.",
-      isOptional: true,
-      defaultValue: "{ redact: true }",
-    },
-    {
-      name: "customRouteAuthConfig",
-      type: "Map<string, boolean>",
-      description: "Per-route auth overrides. Keys are `METHOD:PATH` (e.g., `GET:/api/health`). Value `false` makes route public, `true` requires auth.",
-      isOptional: true,
-    },
-  ]}
-/>
+- [@mastra/express](/reference/v1/server/express-adapter): Express framework adapter.
+- [@mastra/hono](/reference/v1/server/hono-adapter): Hono framework adapter.
+
+## Installation
+
+Install the adapter for the framework you’re using.
+
+<Tabs>
+  <TabItem value="express" label="Express">
+
+```bash
+npm install @mastra/express@beta
+```
+  </TabItem>
+  <TabItem value="hono" label="Hono">
+
+```bash
+npm install @mastra/hono@beta
+```
+  </TabItem>
+</Tabs>
+
+## Configuration
+
+Initialize your Express or Hono app as usual, then create a `MastraServer` by passing in the `app` and your main `mastra` instance from `src/mastra`. Calling `init()` automatically registers Mastra middleware and all available endpoints. You can continue adding your own routes as normal, either before or after `init()`, and they’ll run alongside Mastra’s endpoints.
+
+<Tabs>
+  <TabItem value="express" label="Express">
+
+```typescript {8} title="express-server.ts" showLineNumbers
+import express from "express";
+import { MastraServer } from "@mastra/express";
+import { mastra } from "./mastra"; // src/mastra/index.ts
+
+const app = express();
+app.use(express.json());
+
+const server = new MastraServer({ app, mastra });
+
+await server.init();
+
+app.listen(4111, () => {
+  console.log('Server running on port 4111');
+});
+```
+
+  </TabItem>
+  <TabItem value="hono" label="Hono">
+
+```typescript {8} title="hono-server.ts" showLineNumbers
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { HonoBindings, HonoVariables, MastraServer } from "@mastra/hono";
+import { mastra } from "./mastra"; // src/mastra/index.ts
+
+const app = new Hono<{ Bindings: HonoBindings; Variables: HonoVariables }>();
+
+const server = new MastraServer({ app, mastra });
+
+await server.init();
+
+serve({ fetch: app.fetch, port: 4111 }, () => {
+  console.log('Server running on port 4111');
+});
+```
+
+  </TabItem>
+</Tabs>
+
+> See the [Express Adapter](/reference/v1/server/express-adapter) or [Hono Adapter](/reference/v1/server/hono-adapter)  docs for full configuration options.
+
 
 ## Initialization flow
 
 Calling `init()` runs three steps in order. Understanding this flow helps when you need to insert your own middleware at specific points.
 
-1. **`registerContextMiddleware()`** - Attaches the Mastra instance, request context, tools, and abort signal to every request. This makes Mastra available to all subsequent middleware and route handlers.
-2. **`registerAuthMiddleware()`** - Adds authentication and authorization middleware, but only if `server.auth` is configured in your Mastra instance. Skipped entirely if no auth is configured.
-3. **`registerRoutes()`** - Registers all Mastra API routes for agents, workflows, and other features. Also registers MCP routes if MCP servers are configured.
+1. `registerContextMiddleware()`: Attaches the Mastra instance, request context, tools, and abort signal to every request. This makes Mastra available to all subsequent middleware and route handlers.
+2. `registerAuthMiddleware()`: Adds authentication and authorization middleware, but only if `server.auth` is configured in your Mastra instance. Skipped entirely if no auth is configured.
+3. `registerRoutes()`: Registers all Mastra API routes for agents, workflows, and other features. Also registers MCP routes if MCP servers are configured.
 
 ### Manual initialization
 
@@ -132,18 +132,19 @@ Use manual initialization when you need middleware that runs before Mastra's con
 
 ## Adding custom routes
 
-You can add your own routes to the app alongside Mastra's routes. Routes added after `init()` have access to the Mastra context (the Mastra instance, request context, authenticated user, etc.) through framework-specific mechanisms.
+You can add your own routes to the app alongside Mastra's routes.
+
+- Routes added **before** `init()` won't have Mastra context available.
+- Routes added **after** `init()` have access to the Mastra context (the Mastra instance, request context, authenticated user, etc.).
 
-The timing matters: routes added before `init()` won't have Mastra context available, while routes added after `init()` will. See the framework-specific docs for syntax and examples:
+> See adding custom routes for [Express](/reference/v1/server/express-adapter#adding-custom-routes) and [Hono](/reference/v1/server/hono-adapter#adding-custom-routes) for more information.
 
-- [Hono: Adding custom routes](/reference/v1/server/hono-adapter#adding-custom-routes)
-- [Express: Adding custom routes](/reference/v1/server/express-adapter#adding-custom-routes)
 
 ## Route prefixes
 
 By default, Mastra routes are registered at `/api/agents`, `/api/workflows`, etc. Use the `prefix` option to change this, which is useful for API versioning or when integrating with an existing app that has its own `/api` routes.
 
-```typescript copy showLineNumbers
+```typescript showLineNumbers copy
 const server = new MastraServer({
   app,
   mastra,
@@ -157,7 +158,7 @@ With this prefix, Mastra routes become `/api/v2/agents`, `/api/v2/workflows`, et
 
 Mastra can generate an OpenAPI specification for all registered routes. This is useful for documentation, client generation, or integration with API tools. Enable it by setting the `openapiPath` option:
 
-```typescript copy showLineNumbers
+```typescript showLineNumbers copy
 const server = new MastraServer({
   app,
   mastra,
@@ -178,9 +179,9 @@ When streaming agent responses over HTTP, the HTTP streaming layer redacts sensi
 
 This redaction happens at the HTTP boundary, so internal callbacks like `onStepFinish` still have access to the full request data for debugging and observability purposes.
 
-By default, redaction is enabled. Configure this behavior via `streamOptions`:
+By default, redaction is enabled. Configure this behavior via `streamOptions`. Set `redact: false` only for internal services or debugging scenarios where you need access to the full request data in stream responses.
 
-```typescript copy showLineNumbers
+```typescript showLineNumbers copy
 const server = new MastraServer({
   app,
   mastra,
@@ -190,15 +191,15 @@ const server = new MastraServer({
 });
 ```
 
-Set `redact: false` only for internal services or debugging scenarios where you need access to the full request data in stream responses.
+> See [MastraServer](/reference/v1/server/mastra-server) for full configuration options.
 
 ## Per-route auth overrides
 
 When authentication is configured on your Mastra instance, all routes require authentication by default. Sometimes you need exceptions: public health check endpoints, webhook receivers, or admin routes that need stricter controls.
 
-Use `customRouteAuthConfig` to override authentication behavior for specific routes:
+Use `customRouteAuthConfig` to override authentication behavior for specific routes. Keys follow the format `METHOD:PATH` where method is `GET`, `POST`, `PUT`, `DELETE`, or `ALL`. Paths support wildcards (`*`) for matching multiple routes. Setting a value to `false` makes the route public, while `true` requires authentication.
 
-```typescript copy showLineNumbers
+```typescript showLineNumbers copy
 const server = new MastraServer({
   app,
   mastra,
@@ -212,13 +213,15 @@ const server = new MastraServer({
 });
 ```
 
-Keys follow the format `METHOD:PATH` where method is `GET`, `POST`, `PUT`, `DELETE`, or `ALL`. Paths support wildcards (`*`) for matching multiple routes. Setting a value to `false` makes the route public, while `true` requires authentication.
+
+
+> See [MastraServer](/reference/v1/server/mastra-server) for full configuration options.
 
 ## Accessing the app
 
-After creating the adapter, you may need to access the underlying framework app instance—for example, to pass it to a platform's serve function or to add routes programmatically from another module.
+After creating the adapter, you may still need access to the underlying framework app. This is useful when passing it to a platform’s `serve` function or when adding routes from another module.
 
-```typescript copy showLineNumbers
+```typescript showLineNumbers copy
 // Via the MastraServer instance
 const app = server.getApp();