@mastra/mcp-docs-server 1.0.0-beta.2 → 1.0.0-beta.4

package/.docs/raw/guides/quickstarts/standalone-server.mdx

@@ -0,0 +1,86 @@
+---
+title: "Standalone Server Quickstart"
+description: Get started with Mastra using the create mastra CLI to build a standalone server with agents, workflows, and tools.
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+import Steps from "@site/src/components/Steps";
+import StepItem from "@site/src/components/StepItem";
+import { VideoPlayer } from "@site/src/components/video-player";
+
+# Standalone Server Quickstart
+
+The `create mastra` CLI command is the quickest way to spin up a standalone Mastra server. It walks you through setup and creates example agents, workflows, and tools for you to run locally or adapt
+
+If you need more control over the setup, see the [manual installation guide](/guides/v1/guide/manual-install). You can also use [`mastra init`](/reference/v1/cli/mastra#mastra-init) for existing projects.
+
+## Before you begin
+
+* You'll need an API key from a supported [model provider](/models/v1). If you don't have a preference, use [OpenAI](/models/v1/providers/openai).
+
+## Initialize Mastra
+
+You can run `create mastra` anywhere on your machine.
+
+When prompted, choose a provider (e.g. OpenAI) and enter your key:
+
+<Tabs>
+<TabItem value="npm" label="npm">
+
+```bash copy
+npm create mastra@beta
+```
+
+</TabItem>
+<TabItem value="pnpm" label="pnpm">
+
+```bash copy
+pnpm create mastra@beta
+```
+
+</TabItem>
+<TabItem value="yarn" label="yarn">
+
+```bash copy
+yarn create mastra@beta
+```
+
+</TabItem>
+<TabItem value="bun" label="bun">
+
+```bash copy
+bun create mastra@beta
+```
+
+</TabItem>
+</Tabs>
+
+This creates a new directory for your project with a `src/mastra` folder containing an example weather agent and the following files:
+
+- `index.ts` - Mastra config, including memory
+- `tools/weather-tool.ts` - a tool to fetch weather for a given location
+- `agents/weather-agent.ts` - a weather agent with a prompt that uses the tool
+
+:::tip
+
+You can use [flags](/reference/v1/cli/create-mastra#cli-flags)  with `create mastra` like `--no-example` to skip the example weather agent or `--template` to start from a specific [template](/docs/v1/getting-started/templates)
+
+:::
+
+## Test your agent
+
+Once setup is complete, follow the instructions in your terminal to start the Mastra dev server, then open Studio at [localhost:4111](http://localhost:4111).
+
+Try asking about the weather. If your API key is set up correctly, you'll get a response:
+
+<VideoPlayer src="https://res.cloudinary.com/mastra-assets/video/upload/v1751406022/local-dev-agents-playground_100_m3begx.mp4" />
+
+[Studio](/docs/v1/getting-started/studio) lets you rapidly build and prototype agents without needing to build a UI. Once you're ready, you can integrate your Mastra agent into your app using the guides below.
+
+## Next steps
+
+- Integrate Mastra with your frontend framework: [Next.js](/docs/v1/frameworks/web-frameworks/next-js), [React](/docs/v1/frameworks/web-frameworks/vite-react), or [Astro](/docs/v1/frameworks/web-frameworks/astro)
+- Read more about [Mastra's features](/docs/v1#why-mastra)
+- Build an agent from scratch following one of our [guides](/guides/v1)
+- Watch conceptual guides on our [YouTube channel](https://www.youtube.com/@mastra-ai) and [subscribe](https://www.youtube.com/@mastra-ai?sub_confirmation=1)

package/.docs/raw/index.mdx

@@ -1,5 +1,5 @@
 ---
-title: "About Mastra | Mastra Docs"
+title: "About Mastra"
 sidebar_position: 2
 sidebar_label: "Introduction"
 description: "Mastra is an all-in-one framework for building AI-powered applications and agents with a modern TypeScript stack."
@@ -51,8 +51,8 @@ Explore real-world examples in our [community showcase](/showcase).
 
 ## Get started
 
-Follow the [Installation guide](/docs/v1/getting-started/installation) for step-by-step setup with the CLI or a manual install.
+Choose a [quickstart](/docs/v1/getting-started/quickstart) to get started, or see the [manual installation guide](/guides/v1/guide/manual-install) if you need more control over your setup.
 
-If you're new to AI agents, check out our [templates](/docs/v1/getting-started/templates), [course](https://mastra.ai/book), and [YouTube videos](https://youtube.com/@mastra-ai) to start building with Mastra today.
+If you're new to AI agents, check out our [templates](/docs/v1/getting-started/templates), [course](https://mastra.ai/course), and [YouTube videos](https://youtube.com/@mastra-ai). You can also join our [Discord](https://discord.gg/BTYqqHKUrf) community to get help and share your projects.
 
 We can't wait to see what you build ✌️

package/.docs/raw/logging.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Logging | Observability | Mastra Docs"
+title: "Logging | Observability"
 description: Learn how to use logging in Mastra to monitor execution, capture application behavior, and improve the accuracy of AI applications.
 ---
 
@@ -7,14 +7,14 @@ description: Learn how to use logging in Mastra to monitor execution, capture ap
 
 Mastra's logging system captures function execution, input data, and output responses in a structured format.
 
-When deploying to Mastra Cloud, logs are shown on the [Logs](/docs/v1/mastra-cloud/observability) page. In self-hosted or custom environments, logs can be directed to files or external services depending on the configured transports.
+When deploying to Mastra Cloud, logs are shown on the [Logs](/docs/v1/deployment/mastra-cloud/observability) page. In self-hosted or custom environments, logs can be directed to files or external services depending on the configured transports.
 
-## PinoLogger
+## Configuring logs with PinoLogger
 
-When [initializing a new Mastra project](/docs/v1/getting-started/installation) using the CLI, `PinoLogger` is included by default.
+When [initializing a new Mastra project](/guides/v1/quickstarts/standalone-server) using the CLI, `PinoLogger` is included by default.
 
 ```typescript title="src/mastra/index.ts" showLineNumbers copy
-import { Mastra } from "@mastra/core";
+import { Mastra } from "@mastra/core/mastra";
 import { PinoLogger } from "@mastra/loggers";
 
 export const mastra = new Mastra({
@@ -28,7 +28,7 @@ export const mastra = new Mastra({
 
 > See the [PinoLogger](/reference/v1/logging/pino-logger) API reference for all available configuration options.
 
-## Logging from workflows and tools
+## Customizing logs
 
 Mastra provides access to a logger instance via the `mastra.getLogger()` method, available inside both workflow steps and tools. The logger supports standard severity levels: `debug`, `info`, `warn`, and `error`.
 
@@ -79,7 +79,7 @@ export const testTool = createTool({
 });
 ```
 
-## Logging with additional data
+### Logging with additional data
 
 Logger methods accept an optional second argument for additional data. This can be any value, such as an object, string, or number.
 

package/.docs/raw/mcp/overview.mdx

@@ -0,0 +1,360 @@
+---
+title: "MCP Overview | MCP"
+description: Learn about the Model Context Protocol (MCP), how to use third-party tools via MCPClient, connect to registries, and share your own tools using MCPServer.
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# MCP Overview
+
+Mastra supports the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction), an open standard for connecting AI agents to external tools and resources. It serves as a universal plugin system, enabling agents to call tools regardless of language or hosting environment.
+
+Mastra can also be used to author MCP servers, exposing agents, tools, and other structured resources via the MCP interface. These can then be accessed by any system or agent that supports the protocol.
+
+Mastra currently supports two MCP classes:
+
+1. **`MCPClient`**: Connects to one or many MCP servers to access their tools, resources, prompts, and handle elicitation requests.
+2. **`MCPServer`**: Exposes Mastra tools, agents, workflows, prompts, and resources to MCP-compatible clients.
+
+## Getting started
+
+To use MCP, install the required dependency:
+
+```bash
+npm install @mastra/mcp@beta
+```
+
+## Configuring `MCPClient`
+
+The `MCPClient` connects Mastra primitives to external MCP servers, which can be local packages (invoked using `npx`) or remote HTTP(S) endpoints. Each server must be configured with either a `command` or a `url`, depending on how it's hosted.
+
+```typescript title="src/mastra/mcp/test-mcp-client.ts" showLineNumbers copy
+import { MCPClient } from "@mastra/mcp";
+
+export const testMcpClient = new MCPClient({
+  id: "test-mcp-client",
+  servers: {
+    wikipedia: {
+      command: "npx",
+      args: ["-y", "wikipedia-mcp"],
+    },
+    weather: {
+      url: new URL(
+        `https://server.smithery.ai/@smithery-ai/national-weather-service/mcp?api_key=${process.env.SMITHERY_API_KEY}`,
+      ),
+    },
+  },
+});
+```
+
+> See [MCPClient](/reference/v1/tools/mcp-client) for a full list of configuration options.
+
+## Using `MCPClient` with an agent
+
+To use tools from an MCP server in an agent, import your `MCPClient` and call `.getTools()` in the `tools` parameter. This loads from the defined MCP servers, making them available to the agent.
+
+```typescript {4,16} title="src/mastra/agents/test-agent.ts" showLineNumbers copy
+import { openai } from "@ai-sdk/openai";
+import { Agent } from "@mastra/core/agent";
+
+import { testMcpClient } from "../mcp/test-mcp-client";
+
+export const testAgent = new Agent({
+  name: "Test Agent",
+  description: "You are a helpful AI assistant",
+  instructions: `
+      You are a helpful assistant that has access to the following MCP Servers.
+      - Wikipedia MCP Server
+      - US National Weather Service
+
+      Answer questions using the information you find using the MCP Servers.`,
+  model: openai("gpt-4o-mini"),
+  tools: await testMcpClient.getTools(),
+});
+```
+
+> See the [Agent Class](/reference/v1/agents/agent) for a full list of configuration options.
+
+## Configuring `MCPServer`
+
+To expose agents, tools, and workflows from your Mastra application to external systems over HTTP(S) use the `MCPServer` class. This makes them accessible to any system or agent that supports the protocol.
+
+```typescript title="src/mastra/mcp/test-mcp-server.ts" showLineNumbers copy
+import { MCPServer } from "@mastra/mcp";
+
+import { testAgent } from "../agents/test-agent";
+import { testWorkflow } from "../workflows/test-workflow";
+import { testTool } from "../tools/test-tool";
+
+export const testMcpServer = new MCPServer({
+  id: "test-mcp-server",
+  name: "Test Server",
+  version: "1.0.0",
+  agents: { testAgent },
+  tools: { testTool },
+  workflows: { testWorkflow },
+});
+```
+
+> See [MCPServer](/reference/v1/tools/mcp-server) for a full list of configuration options.
+
+## Registering an `MCPServer`
+
+To make an MCP server available to other systems or agents that support the protocol, register it in the main `Mastra` instance using `mcpServers`.
+
+```typescript title="src/mastra/index.ts" showLineNumbers copy
+import { Mastra } from "@mastra/core/mastra";
+
+import { testMcpServer } from "./mcp/test-mcp-server";
+
+export const mastra = new Mastra({
+  // ...
+  mcpServers: { testMcpServer },
+});
+```
+
+## Static and dynamic tools
+
+`MCPClient` offers two approaches to retrieving tools from connected servers, suitable for different application architectures:
+
+| Feature           | Static Configuration (`await mcp.getTools()`) | Dynamic Configuration (`await mcp.getToolsets()`)    |
+| :---------------- | :-------------------------------------------- | :--------------------------------------------------- |
+| **Use Case**      | Single-user, static config (e.g., CLI tool)   | Multi-user, dynamic config (e.g., SaaS app)          |
+| **Configuration** | Fixed at agent initialization                 | Per-request, dynamic                                 |
+| **Credentials**   | Shared across all uses                        | Can vary per user/request                            |
+| **Agent Setup**   | Tools added in `Agent` constructor            | Tools passed in `.generate()` or `.stream()` options |
+
+### Static tools
+
+Use the `.getTools()` method to fetch tools from all configured MCP servers. This is suitable when configuration (such as API keys) is static and consistent across users or requests. Call it once and pass the result to the `tools` property when defining your agent.
+
+> See [getTools()](/reference/v1/tools/mcp-client#gettools) for more information.
+
+```typescript {8} title="src/mastra/agents/test-agent.ts" showLineNumbers copy
+import { openai } from "@ai-sdk/openai";
+import { Agent } from "@mastra/core/agent";
+
+import { testMcpClient } from "../mcp/test-mcp-client";
+
+export const testAgent = new Agent({
+  // ...
+  tools: await testMcpClient.getTools(),
+});
+```
+
+### Dynamic tools
+
+Use the `.getToolsets()` method when tool configuration may vary by request or user, such as in a multi-tenant system where each user provides their own API key. This method returns toolsets that can be passed to the `toolsets` option in the agent's `.generate()` or `.stream()` calls.
+
+```typescript {5-16,21} showLineNumbers copy
+import { MCPClient } from "@mastra/mcp";
+import { mastra } from "./mastra";
+
+async function handleRequest(userPrompt: string, userApiKey: string) {
+  const userMcp = new MCPClient({
+    servers: {
+      weather: {
+        url: new URL("http://localhost:8080/mcp"),
+        requestInit: {
+          headers: {
+            Authorization: `Bearer ${userApiKey}`,
+          },
+        },
+      },
+    },
+  });
+
+  const agent = mastra.getAgent("testAgent");
+
+  const response = await agent.generate(userPrompt, {
+    toolsets: await userMcp.getToolsets(),
+  });
+
+  await userMcp.disconnect();
+
+  return Response.json({
+    data: response.text,
+  });
+}
+```
+
+> See [getToolsets()](/reference/v1/tools/mcp-client#gettoolsets) for more information.
+
+## Connecting to an MCP registry
+
+MCP servers can be discovered through registries. Here's how to connect to some popular ones using `MCPClient`:
+
+<Tabs>
+  <TabItem value="klavis" label="Klavis AI">
+    [Klavis AI](https://klavis.ai) provides hosted, enterprise-authenticated, high-quality MCP servers.
+
+    ```typescript
+    import { MCPClient } from "@mastra/mcp";
+
+    const mcp = new MCPClient({
+      servers: {
+        salesforce: {
+          url: new URL("https://salesforce-mcp-server.klavis.ai/mcp/?instance_id={private-instance-id}"),
+        },
+        hubspot: {
+          url: new URL("https://hubspot-mcp-server.klavis.ai/mcp/?instance_id={private-instance-id}"),
+        },
+      },
+    });
+    ```
+
+    Klavis AI offers enterprise-grade authentication and security for production deployments.
+
+    For more details on how to integrate Mastra with Klavis, check out their [documentation](https://docs.klavis.ai/documentation/ai-platform-integration/mastra).
+
+  </TabItem>
+  <TabItem value="mcp-run" label="mcp.run">
+    [mcp.run](https://www.mcp.run/) provides pre-authenticated, managed MCP servers. Tools are grouped into Profiles, each with a unique, signed URL.
+
+    ```typescript
+    import { MCPClient } from "@mastra/mcp";
+
+    const mcp = new MCPClient({
+      servers: {
+        marketing: { // Example profile name
+          url: new URL(process.env.MCP_RUN_SSE_URL!), // Get URL from mcp.run profile
+        },
+      },
+    });
+    ```
+
+    > **Important:** Treat the mcp.run SSE URL like a password. Store it securely, for example, in an environment variable.
+    > ```bash title=".env"
+    > MCP_RUN_SSE_URL=https://www.mcp.run/api/mcp/sse?nonce=...
+    > ```
+
+  </TabItem>
+  <TabItem value="composio" label="Composio.dev">
+    [Composio.dev](https://composio.dev) offers a registry of [SSE-based MCP servers](https://mcp.composio.dev). You can use the SSE URL generated for tools like Cursor directly.
+
+    ```typescript
+    import { MCPClient } from "@mastra/mcp";
+
+    const mcp = new MCPClient({
+      servers: {
+        googleSheets: {
+          url: new URL("https://mcp.composio.dev/googlesheets/[private-url-path]"),
+        },
+        gmail: {
+          url: new URL("https://mcp.composio.dev/gmail/[private-url-path]"),
+        },
+      },
+    });
+    ```
+
+    Authentication with services like Google Sheets often happens interactively through the agent conversation.
+
+    *Note: Composio URLs are typically tied to a single user account, making them best suited for personal automation rather than multi-tenant applications.*
+
+  </TabItem>
+  <TabItem value="smithery" label="Smithery.ai">
+    [Smithery.ai](https://smithery.ai) provides a registry accessible via their CLI.
+
+    ```typescript
+    // Unix/Mac
+    import { MCPClient } from "@mastra/mcp";
+
+    const mcp = new MCPClient({
+      servers: {
+        sequentialThinking: {
+          command: "npx",
+          args: [
+            "-y",
+            "@smithery/cli@latest",
+            "run",
+            "@smithery-ai/server-sequential-thinking",
+            "--config",
+            "{}",
+          ],
+        },
+      },
+    });
+    ```
+
+    ```typescript
+    // Windows
+    import { MCPClient } from "@mastra/mcp";
+
+    const mcp = new MCPClient({
+      servers: {
+        sequentialThinking: {
+          command: "npx",
+          args: [
+            "-y",
+            "@smithery/cli@latest",
+            "run",
+            "@smithery-ai/server-sequential-thinking",
+            "--config",
+            "{}",
+          ],
+        },
+      },
+    });
+    ```
+
+  </TabItem>
+  <TabItem value="ampersand" label="Ampersand">
+
+[Ampersand](https://withampersand.com?utm_source=mastra-docs) offers an [MCP Server](https://docs.withampersand.com/mcp) that allows you to connect your agent to 150+ integrations with SaaS products like Salesforce, Hubspot, and Zendesk.
+
+```typescript
+// MCPClient with Ampersand MCP Server using SSE
+export const mcp = new MCPClient({
+  servers: {
+    "@amp-labs/mcp-server": {
+      url: `https://mcp.withampersand.com/v1/sse?${new URLSearchParams({
+        apiKey: process.env.AMPERSAND_API_KEY,
+        project: process.env.AMPERSAND_PROJECT_ID,
+        integrationName: process.env.AMPERSAND_INTEGRATION_NAME,
+        groupRef: process.env.AMPERSAND_GROUP_REF,
+      })}`,
+    },
+  },
+});
+```
+
+```typescript
+// If you prefer to run the MCP server locally:
+import { MCPClient } from "@mastra/mcp";
+
+// MCPClient with Ampersand MCP Server using stdio transport
+export const mcp = new MCPClient({
+  servers: {
+    "@amp-labs/mcp-server": {
+      command: "npx",
+      args: [
+        "-y",
+        "@amp-labs/mcp-server@latest",
+        "--transport",
+        "stdio",
+        "--project",
+        process.env.AMPERSAND_PROJECT_ID,
+        "--integrationName",
+        process.env.AMPERSAND_INTEGRATION_NAME,
+        "--groupRef",
+        process.env.AMPERSAND_GROUP_REF, // optional
+      ],
+      env: {
+        AMPERSAND_API_KEY: process.env.AMPERSAND_API_KEY,
+      },
+    },
+  },
+});
+```
+
+As an alternative to MCP, Ampersand's AI SDK also has an adapter for Mastra, so you can [directly import Ampersand tools](https://docs.withampersand.com/ai-sdk#use-with-mastra) for your agent to access.
+
+  </TabItem>
+</Tabs>
+
+## Related
+
+- [Using Tools](/docs/v1/agents/using-tools)
+- [MCPClient](/reference/v1/tools/mcp-client)
+- [MCPServer](/reference/v1/tools/mcp-server)

package/.docs/raw/mcp/publishing-mcp-server.mdx

@@ -0,0 +1,139 @@
+---
+title: "Publishing an MCP Server | MCP"
+description: Guide to setting up and building a Mastra MCP server using the stdio transport, and publishing it to NPM.
+---
+
+import Steps from "@site/src/components/Steps";
+import StepItem from "@site/src/components/StepItem";
+
+# Publishing an MCP Server
+
+This example guides you through setting up a basic Mastra MCPServer using the stdio transport, building it, and preparing it for publishing to NPM.
+
+## Install dependencies
+
+Install the necessary packages:
+
+```bash
+pnpm add @mastra/mcp @mastra/core tsup
+```
+
+## Setting up an MCP Server
+
+<Steps>
+
+<StepItem>
+
+Create a file for your stdio server, for example, `/src/mastra/stdio.ts`.
+
+</StepItem>
+
+<StepItem>
+
+Add the following code to the file. Remember to import your actual Mastra tools and name the server appropriately.
+
+```typescript title="src/mastra/stdio.ts" copy
+#!/usr/bin/env node
+import { MCPServer } from "@mastra/mcp";
+import { weatherTool } from "./tools";
+
+const server = new MCPServer({
+  name: "my-mcp-server",
+  version: "1.0.0",
+  tools: { weatherTool },
+});
+
+server.startStdio().catch((error) => {
+  console.error("Error running MCP server:", error);
+  process.exit(1);
+});
+```
+
+</StepItem>
+
+<StepItem>
+
+Update your `package.json` to include the `bin` entry pointing to your built server file and a script to build the server with both ESM and CJS outputs.
+
+```json title="package.json" copy
+{
+  "bin": "dist/stdio.mjs",
+  "scripts": {
+    "build:mcp": "tsup src/mastra/stdio.ts --format esm,cjs --no-splitting --dts && echo '#!/usr/bin/env node' | cat - dist/stdio.mjs > temp && mv temp dist/stdio.mjs && chmod +x dist/stdio.mjs"
+  }
+}
+```
+
+The build command generates both ESM (`.mjs`) and CJS (`.cjs`) outputs for maximum compatibility. The shebang (`#!/usr/bin/env node`) is prepended to the ESM artifact to make it directly executable, and the `bin` entry points to this file.
+
+</StepItem>
+
+<StepItem>
+
+Run the build command:
+
+```bash
+pnpm run build:mcp
+```
+
+This will compile your server code into both ESM and CJS formats and make the ESM output file executable. On Unix-like systems, the `chmod +x` step makes the file directly executable. Windows users may need to use WSL or handle execution through Node.js directly.
+
+</StepItem>
+
+</Steps>
+
+## Publishing to NPM
+
+To make your MCP server available for others (or yourself) to use via `npx` or as a dependency, you can publish it to NPM.
+
+<Steps>
+
+<StepItem>
+
+Ensure you have an NPM account and are logged in (`npm login`).
+
+</StepItem>
+
+<StepItem>
+
+Make sure your package name in `package.json` is unique and available.
+
+</StepItem>
+
+<StepItem>
+
+Run the publish command from your project root after building:
+
+```bash
+npm publish --access public
+```
+
+For more details on publishing packages, refer to the [NPM documentation](https://docs.npmjs.com/creating-and-publishing-scoped-public-packages).
+
+</StepItem>
+
+</Steps>
+
+## Using a published MCP Server
+
+Once published, your MCP server can be used by an `MCPClient` by specifying the command to run your package. You can also use any other MCP client like Claude desktop, Cursor, or Windsurf.
+
+```typescript
+import { MCPClient } from "@mastra/mcp";
+
+const mcp = new MCPClient({
+  servers: {
+    // Give this MCP server instance a name
+    yourServerName: {
+      command: "npx",
+      args: ["-y", "@your-org-name/your-package-name@latest"], // Replace with your package name
+    },
+  },
+});
+
+// You can then get tools or toolsets from this configuration to use in your agent
+const tools = await mcp.getTools();
+const toolsets = await mcp.getToolsets();
+```
+
+Note: If you published without an organization scope, the `args` might just be `["-y", "your-package-name@latest"]`.

package/.docs/raw/memory/conversation-history.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Conversation History | Memory | Mastra Docs"
+title: "Conversation History | Memory"
 description: "Learn how to configure conversation history in Mastra to store recent messages from the current conversation."
 ---
 

package/.docs/raw/memory/memory-processors.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Memory Processors | Memory | Mastra Docs"
+title: "Memory Processors | Memory"
 description: "Learn how to use memory processors in Mastra to filter, trim, and transform messages before they're sent to the language model to manage context window limits."
 ---
 

package/.docs/raw/memory/overview.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Memory overview | Memory | Mastra Docs"
+title: "Memory overview | Memory"
 description: "Learn how Mastra's memory system works with working memory, conversation history, and semantic recall."
 ---
 

package/.docs/raw/memory/semantic-recall.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Semantic Recall | Memory | Mastra Docs"
+title: "Semantic Recall | Memory"
 description: "Learn how to use semantic recall in Mastra to retrieve relevant messages from past conversations using vector search and embeddings."
 ---