@mastra/mcp-docs-server 1.2.15-alpha.9 → 1.2.16-alpha.1

package/.docs/docs/long-running-agents/signals.md

@@ -4,7 +4,7 @@
 
 **Added in:** `@mastra/core@1.39.0`
 
-> **Beta:** This feature is in beta. Breaking changes may occur without a major version bump until the API is stable.
+> **Beta:** Breaking changes may occur without a major version bump until the API is stable.
 
 Signals are a way to interact with an agent through a thread. Instead of starting every interaction with `agent.stream()`, subscribe to a thread and send messages or signals. Mastra either wakes the agent when the thread is idle or drops input into the running agent loop, or alternatively queues input for the next turn.
 
@@ -147,7 +147,7 @@ Use XML-safe `tagName` and attribute names. They can contain letters, numbers, s
 
 #### Storage support
 
-Notification inbox storage is available in the storage adapters that support richer memory and signal workflows: [libSQL](https://mastra.ai/reference/storage/libsql), [PostgreSQL](https://mastra.ai/reference/storage/postgresql), and [MongoDB](https://mastra.ai/reference/storage/mongodb). These adapters expose notification records through `getStore('notifications')`.
+Notification inbox storage is available in the storage adapters that support richer memory and signal workflows: [libSQL](https://mastra.ai/integrations/databases/libsql), [PostgreSQL](https://mastra.ai/integrations/databases/postgresql), and [MongoDB](https://mastra.ai/integrations/databases/mongodb). These adapters expose notification records through `getStore('notifications')`.
 
 ### Send processor context
 

package/.docs/docs/mastra-platform/database.md

@@ -99,7 +99,7 @@ When a database is `ready`, the provider has finished provisioning and the platf
 
 ### Turso (LibSQL)
 
-Turso exposes two environment variables: `TURSO_DATABASE_URL` and `TURSO_AUTH_TOKEN`. The following example connects a [LibSQLStore](https://mastra.ai/reference/storage/libsql) using those variables.
+Turso exposes two environment variables: `TURSO_DATABASE_URL` and `TURSO_AUTH_TOKEN`. The following example connects a [LibSQLStore](https://mastra.ai/integrations/databases/libsql) using those variables.
 
 ```ts
 import { LibSQLStore } from '@mastra/libsql'
@@ -139,7 +139,7 @@ bun add @mastra/libsql@latest
 
 ### PostgreSQL
 
-PostgreSQL exposes a single `DATABASE_URL` connection string. The following example connects a [PostgresStore](https://mastra.ai/reference/storage/postgresql) using that variable.
+PostgreSQL exposes a single `DATABASE_URL` connection string. The following example connects a [PostgresStore](https://mastra.ai/integrations/databases/postgresql) using that variable.
 
 ```ts
 import { PostgresStore } from '@mastra/pg'

package/.docs/docs/mastra-platform/deploy.md

@@ -14,7 +14,7 @@ mastra deploy
 
 ## Before you begin
 
-You'll need a [Mastra application](https://mastra.ai/guides/getting-started/quickstart) and a [Mastra platform](https://projects.mastra.ai) account. If you're not authenticated, the CLI prompts you to log in on first use.
+You'll need a [Mastra application](https://mastra.ai/docs) and a [Mastra platform](https://projects.mastra.ai) account. If you're not authenticated, the CLI prompts you to log in on first use.
 
 A local `.env` file is optional. Environment variables stored on the platform are used as-is at deploy time, and managed resources like [hosted databases](https://mastra.ai/docs/mastra-platform/database) inject their own variables. Pass `--env-file` only when you want to layer local values on top.
 
@@ -132,6 +132,33 @@ mastra deploy --env staging --env-file .env.staging
 
 To change variables on a running service without a redeploy, update them in the dashboard and run [`mastra env restart`](https://mastra.ai/reference/cli/mastra).
 
+## Private npm packages
+
+Projects that depend on packages from a private registry install them during the deploy using the standard `NPM_TOKEN` contract.
+
+1. Store a read-only registry token as `NPM_TOKEN` on the project or environment through the dashboard.
+
+2. Commit a token-free `.npmrc` that points your scope at the registry and reads the token from the environment:
+
+   ```ini
+   @your-org:registry=https://npm.pkg.github.com
+   //npm.pkg.github.com/:_authToken=${NPM_TOKEN}
+   ```
+
+   Keep the `${NPM_TOKEN}` reference literal. The package manager resolves it at install time, so the token itself never lands in your repository.
+
+3. Deploy as usual:
+
+   ```bash
+   mastra deploy
+   ```
+
+In a monorepo, a `.npmrc` in your project directory takes precedence over one at the repository root.
+
+`NPM_TOKEN` is available during dependency installation. Mastra redacts its value from the Mastra source-build logs that it streams. The generated Dockerfile receives it as a build argument, so the runtime image stays free of the token. `NPM_TOKEN` is also injected into the running service as a regular environment variable, so treat it as a secret your application can read.
+
+Projects without a private-registry `.npmrc` need no changes. When your `.npmrc` references `${NPM_TOKEN}`, set the variable or the dependency install fails.
+
 ## Project resolution
 
 Every deploy resolves its target project in this order:

package/.docs/docs/mastra-platform/observability.md

@@ -2,9 +2,7 @@
 
 # Observability on Mastra platform
 
-Observability on Mastra platform is a standalone hosted product for searchable traces, logs, and metrics across Mastra projects and deploys. Use it when you want observability without deploying Studio first or setting up local storage.
-
-Use `mastra init` to configure platform observability while adding Mastra to an existing application, or configure it manually in a newly created Mastra project.
+Mastra Platform Observability collects traces, logs, metrics, scores, and feedback from Mastra applications. Use it for hosted observability without deploying Studio or Server or configuring local observability storage.
 
 ## Quickstart
 
@@ -12,7 +10,7 @@ Choose the setup path that matches your project.
 
 ### New project
 
-Create a managed Mastra project. When prompted, opt into Mastra Platform Observability to configure it automatically:
+Create a managed Mastra project and enable Mastra Platform Observability when prompted:
 
 **npm**:
 
@@ -38,11 +36,11 @@ yarn create mastra
 bunx create-mastra
 ```
 
-When you select observability, the create command authenticates with Mastra Platform, provisions a platform project, and writes the credentials to your project. If you skip platform setup or use a prompt-free creation flow, follow the [manual setup](#manual-setup) steps instead.
+The create command authenticates with Mastra Platform, creates an observability project, mints an access token, and writes `MASTRA_PLATFORM_ACCESS_TOKEN` and `MASTRA_PROJECT_ID` to `.env`.
 
-### Existing non-Mastra projects
+### Existing project
 
-If you already have an application, such as a Next.js app, but haven't added Mastra yet, run `mastra init` and enable Mastra Observability when prompted:
+If you're adding Mastra to an existing application, run `mastra init` and enable Mastra Observability when prompted:
 
 **npm**:
 
@@ -68,21 +66,33 @@ yarn dlx mastra init
 bun x mastra init
 ```
 
-The CLI can select an existing platform project or create a new one.
+The init command lets you select an existing platform project or create one. It then creates an access token and writes the credentials to `.env`.
+
+## Configure manually
 
-### Manual setup
+Use manual configuration if you skipped platform setup or automatic provisioning failed.
 
-Create a project in [Mastra Platform](https://projects.mastra.ai), add `MASTRA_PLATFORM_ACCESS_TOKEN` and `MASTRA_PROJECT_ID` to `.env`, then register `MastraPlatformExporter` in your Mastra config. Add `MastraStorageExporter` if you also want to persist observability events to your configured Mastra Storage:
+1. In [Mastra Platform](https://projects.mastra.ai), create or open a project.
+2. Create an access token for the project's organization.
+3. Copy the project ID from the project page.
+4. Add both values to `.env`:
 
-```ts
+```bash
+MASTRA_PLATFORM_ACCESS_TOKEN=<your-platform-access-token>
+MASTRA_PROJECT_ID=<your-project-id>
+```
+
+Register [`MastraPlatformExporter`](https://mastra.ai/reference/observability/tracing/exporters/mastra-platform-exporter) in your observability configuration:
+
+```typescript
 import { Mastra } from '@mastra/core/mastra'
-import { Observability, MastraPlatformExporter } from '@mastra/observability'
+import { MastraPlatformExporter, Observability } from '@mastra/observability'
 
 export const mastra = new Mastra({
   observability: new Observability({
     configs: {
       default: {
-        serviceName: 'mastra',
+        serviceName: 'my-service',
         exporters: [new MastraPlatformExporter()],
       },
     },
@@ -90,11 +100,43 @@ export const mastra = new Mastra({
 })
 ```
 
-See [Mastra platform configuration](https://mastra.ai/docs/mastra-platform/configuration) for the environment variables used by platform observability.
+The exporter reads the access token and project ID from the environment. Keep `serviceName` stable so you can distinguish applications and deployments when filtering observability data.
+
+`MastraPlatformExporter` sends ended spans, logs, metrics, scores, and feedback. It buffers events and sends a batch when it reaches 1,000 events or has waited five seconds. Model chunk spans aren't exported.
+
+> **Note:** `MastraPlatformExporter` replaced `CloudExporter`. `CloudExporter` remains available for backward compatibility but is deprecated. Use `MastraPlatformExporter` for new code.
+
+### Store data locally
+
+Add `MastraStorageExporter` if you also want to persist observability data to your configured Mastra storage and inspect it in local Studio:
+
+```typescript
+import { Mastra } from '@mastra/core/mastra'
+import { MastraPlatformExporter, MastraStorageExporter, Observability } from '@mastra/observability'
+
+export const mastra = new Mastra({
+  observability: new Observability({
+    configs: {
+      default: {
+        serviceName: 'my-service',
+        exporters: [new MastraPlatformExporter(), new MastraStorageExporter()],
+      },
+    },
+  }),
+})
+```
+
+See [Mastra storage exporter](https://mastra.ai/docs/observability/integrations/exporters/mastra-storage) for storage requirements and configuration.
+
+## View observability data
+
+Open your project in [Mastra Platform](https://projects.mastra.ai) to inspect exported traces, logs, metrics, scores, and feedback. A Studio or Server deployment isn't required.
+
+Use a consistent `serviceName` to filter data from a specific application or deployment.
 
 ## Query observability data
 
-After your project is publishing traces, logs, or scores to Mastra Platform Observability, you can query that data from your terminal with the Mastra CLI or with `curl`.
+Query hosted observability data from the terminal with the Mastra CLI:
 
 **npm**:
 
@@ -120,8 +162,11 @@ yarn dlx mastra api trace list
 bun x mastra api trace list
 ```
 
-For observability commands, the CLI targets the hosted observability API and can infer credentials from your project environment. See the [`mastra api` CLI reference](https://mastra.ai/reference/cli/mastra) for available observability commands, filtering, pagination, credential resolution, and direct `curl` examples.
+The CLI can infer platform credentials from your project environment. See the [`mastra api` CLI reference](https://mastra.ai/reference/cli/mastra) for available commands, filtering, pagination, credential resolution, and `curl` examples.
 
-## Related
+## Next steps
 
-- 📹 [Mastra observability and Studio workshop](https://www.youtube.com/watch?v=dKO_a3RPra0)
+- 📹 [Mastra observability and Studio workshop](https://www.youtube.com/watch?v=dKO_a3RPra0)
+- [Configure Mastra Platform](https://mastra.ai/docs/mastra-platform/configuration)
+- [Learn about observability](https://mastra.ai/docs/observability/overview)
+- [Configure `MastraPlatformExporter`](https://mastra.ai/reference/observability/tracing/exporters/mastra-platform-exporter)

package/.docs/docs/mastra-platform/overview.md

@@ -40,4 +40,4 @@ Once you're ready to deploy your application to production, run [`mastra deploy`
 
 Follow the [Deploy](https://mastra.ai/docs/mastra-platform/deploy) docs for step-by-step instructions.
 
-If you host your Mastra application on your own infrastructure, you can still send observability data to Mastra platform using the [MastraPlatformExporter](https://mastra.ai/docs/observability/integrations/exporters/mastra-platform).
+If you host your Mastra application on your own infrastructure, you can still send observability data to Mastra platform using the [MastraPlatformExporter](https://mastra.ai/docs/mastra-platform/observability).

package/.docs/docs/mastra-platform/server.md

@@ -8,7 +8,7 @@ You get a stable API endpoint, environment variable management, custom domain su
 
 > **Note:** `mastra server deploy` is the earlier split deploy path. New projects should use the unified [`mastra deploy`](https://mastra.ai/docs/mastra-platform/deploy) command, which adds preflight validation, environments, and CLI-managed databases.
 
-> **Note:** Server deploy provisions hosted storage automatically. If you override storage with [LibSQLStore](https://mastra.ai/reference/storage/libsql) and a file URL, switch to a remotely hosted database because Mastra platform uses an ephemeral filesystem.
+> **Note:** Server deploy provisions hosted storage automatically. If you override storage with [LibSQLStore](https://mastra.ai/integrations/databases/libsql) and a file URL, switch to a remotely hosted database because Mastra platform uses an ephemeral filesystem.
 
 ## Quickstart
 

package/.docs/docs/mastra-platform/trace-intelligence.md

@@ -56,12 +56,9 @@ The flow chart connects themes in adjacent trace signal columns:
 
 The flow shows association, not causation or execution order. For example, a ribbon between a Goal and an Outcome means that both themes occurred in the same traces. It doesn't show that the goal caused the outcome.
 
-### Distributions, Other, and Noise
+### Other and Noise
 
-The cards below the flow show each trace signal's theme distribution:
-
-- **Trace count**: The number of distinct traces assigned to a theme in the selected snapshot.
-- **Stage share**: The percentage of analyzed traces for that trace signal assigned to the theme.
+Each node shows its trace count: the number of distinct traces assigned to that theme in the selected snapshot. A theme's details also state its share, for example "28 of 70 traces in this snapshot (40%)".
 
 Studio shows the most common themes for each trace signal type. It may combine smaller themes into **Other** to preserve totals without overcrowding the chart.
 
@@ -69,26 +66,25 @@ Studio shows the most common themes for each trace signal type. It may combine s
 
 ### Snapshots
 
-A snapshot is a moving analysis window over a set of traces. Snapshots can overlap, so don't add their trace counts together. Compare trace count and stage share together because traffic volume can change between windows.
+A snapshot is a moving analysis window over a set of traces. Snapshots can overlap, so don't add their trace counts together. Compare a theme's trace count and its share of the snapshot together because traffic volume can change between windows.
 
 A theme can persist, disappear, split, merge, or return across snapshots. Treat theme names and descriptions as generated summaries, not fixed taxonomies.
 
 ## Use the Trace Intelligence page
 
 1. Use the **Agent** selector to switch between agents with available analysis. An agent doesn't appear until its first themes are ready.
-2. Select a theme in the flow to filter every column to traces containing that theme.
-3. Select **View theme details** to inspect its description, trace count, stage share, generated examples, and history.
+2. Select a theme in the flow to open its details and filter every column to traces containing that theme.
+3. The details panel shows the theme's description, its share of the snapshot, paged example summaries, and a trend of its trace count over time.
 4. Select **Clear filter** to restore the complete flow.
 
 You can also:
 
-- Select a theme in a distribution card to open its details and generated example summaries.
-- Select **Noise** in a distribution card to inspect its distribution and generated example summaries.
-- Drag the distribution cards to reorder the trace signal columns and see a different relationship perspective.
+- Select **Noise** in the flow to inspect its share and generated example summaries.
+- Drag the column headers above the chart to reorder the trace signal columns and see a different relationship perspective.
 - Use the timeline to select a snapshot, or select **Play** to watch themes change over time.
-- Open a theme's history to see whether it persisted and how its coverage changed.
+- Switch to **Compare** to see which themes grew, shrank, entered the range, or left the range between two points in time, or **Lifelines** to follow each theme's share across the whole selected range.
 
-Filtering the flow by a theme is unavailable for snapshots with more than 2,000 traces. Choose another snapshot or clear the active filter to return to the full flow. Theme and Noise details remain available from the distribution cards.
+Filtering the flow by a theme is unavailable for snapshots with more than 2,000 traces. Selecting a theme still opens its details there without filtering the flow.
 
 ## Troubleshooting
 

package/.docs/docs/mcp/overview.md

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# MCP overview
+# MCP
 
 Mastra supports the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction), an open standard for connecting AI agents to external tools and resources.
 
@@ -202,6 +202,48 @@ export const mastra = new Mastra({
 
 Visit the [`MCPServer` reference](https://mastra.ai/reference/tools/mcp-server) for prompts, resources, transports, and other server options.
 
+### Publish a stdio server package
+
+Package a server that uses the standard input/output (stdio) transport when you want clients to run it locally through a command such as `npx`. Create a separate executable entry point that starts the server:
+
+```typescript
+#!/usr/bin/env node
+import { mcpServer } from './server'
+
+mcpServer.startStdio().catch(error => {
+  console.error('Failed to start MCP server:', error)
+  process.exit(1)
+})
+```
+
+Build the entry point as an executable Node.js file, then point the package's `bin` field to that output. Include the built file in the published package and keep the shebang as its first line:
+
+```json
+{
+  "bin": {
+    "my-mcp-server": "dist/stdio.js"
+  },
+  "files": ["dist"]
+}
+```
+
+After publishing the package, configure clients to run it by package name:
+
+```typescript
+import { MCPClient } from '@mastra/mcp'
+
+const mcpClient = new MCPClient({
+  servers: {
+    myServer: {
+      command: 'npx',
+      args: ['-y', '@your-org/my-mcp-server@1.0.0'],
+    },
+  },
+})
+```
+
+Visit the [npm package publishing documentation](https://docs.npmjs.com/creating-and-publishing-scoped-public-packages) for package naming, authentication, and publication commands.
+
 ## Build MCP Apps
 
 The [MCP Apps extension](https://github.com/modelcontextprotocol/ext-apps) lets MCP tools serve interactive HTML interfaces through `ui://` resources. Mastra Studio renders these apps in sandboxed iframes on tool pages and in agent chat.

package/.docs/docs/memory/memory-processors.md

@@ -313,11 +313,11 @@ Both scenarios are safe - guardrails prevent inappropriate content from being pe
 
 Some storage providers enforce record size limits that base64-encoded file attachments can exceed:
 
-| Provider                                                           | Record size limit |
-| ------------------------------------------------------------------ | ----------------- |
-| [DynamoDB](https://mastra.ai/reference/storage/dynamodb)           | 400 KB            |
-| [Convex](https://mastra.ai/reference/storage/convex)               | 1 MiB             |
-| [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1) | 1 MiB             |
+| Provider                                                                | Record size limit |
+| ----------------------------------------------------------------------- | ----------------- |
+| [DynamoDB](https://mastra.ai/integrations/databases/dynamodb)           | 400 KB            |
+| [Convex](https://mastra.ai/integrations/databases/convex)               | 1 MiB             |
+| [Cloudflare D1](https://mastra.ai/integrations/databases/cloudflare-d1) | 1 MiB             |
 
 PostgreSQL, MongoDB, and libSQL have higher limits and are usually unaffected.
 

package/.docs/docs/memory/message-history.md

@@ -6,13 +6,13 @@ Message history is the most basic and important form of memory. It gives the LLM
 
 You can also retrieve message history to display past conversations in your UI.
 
-> **Info:** Each message belongs to a thread (the conversation) and a resource (the user or entity it's associated with). See [Threads and resources](#threads-and-resources) for more detail.
+> **Note:** Each message belongs to a thread (the conversation) and a resource (the user or entity it's associated with). See [Threads and resources](#threads-and-resources) for more detail.
 
 > **Warning:** When you use memory with a client application, send **only the new message** from the client instead of the full conversation history.
 >
 > Sending the full history is redundant because Mastra loads messages from storage, and it can cause message ordering bugs when client-side timestamps conflict with stored timestamps.
 >
-> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/guides/build-your-ui/ai-sdk-ui).
+> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/integrations/agentic-ui/ai-sdk-ui).
 
 ## Threads and resources
 
@@ -113,7 +113,7 @@ await agent.stream('Hello', {
 })
 ```
 
-> **Info:** Threads and messages are created automatically when you call `agent.generate()` or `agent.stream()`, but you can also create them manually with [`createThread()`](https://mastra.ai/reference/memory/createThread) and [`saveMessages()`](https://mastra.ai/reference/memory/memory-class).
+> **Note:** Threads and messages are created automatically when you call `agent.generate()` or `agent.stream()`, but you can also create them manually with [`createThread()`](https://mastra.ai/reference/memory/createThread) and [`saveMessages()`](https://mastra.ai/reference/memory/memory-class).
 
 You can use this history in two ways:
 

package/.docs/docs/memory/multi-user-threads.md

@@ -156,7 +156,7 @@ const memory = new Memory({
 })
 ```
 
-OM requires a storage adapter that supports it: `@mastra/libsql`, `@mastra/pg`, or `@mastra/mongodb`.
+OM requires a storage adapter that supports it: `@mastra/libsql`, `@mastra/pg`, `@mastra/mongodb`, or `@mastra/oracledb`.
 
 > **Note:** If you switch the Observer to a weaker model and see facts collapse to a generic `User`, use [`observation.instruction`](https://mastra.ai/reference/memory/observational-memory) to teach the Observer how to read the `<turn>` tag.
 

package/.docs/docs/memory/observational-memory.md

@@ -92,9 +92,9 @@ See [configuration options](https://mastra.ai/reference/memory/observational-mem
 >
 > Observational memory still relies on stored conversation history. Sending the full history is redundant and can cause message ordering bugs when client-side timestamps conflict with stored timestamps.
 >
-> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/guides/build-your-ui/ai-sdk-ui).
+> For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/integrations/agentic-ui/ai-sdk-ui).
 
-> **Note:** OM currently only supports `@mastra/pg`, `@mastra/libsql`, `@mastra/mysql`, `@mastra/mongodb`, and `@mastra/convex` storage adapters. It uses background agents for managing memory. When no model is set, the default model is `google/gemini-2.5-flash`.
+> **Note:** OM currently only supports `@mastra/pg`, `@mastra/libsql`, `@mastra/mysql`, `@mastra/mongodb`, `@mastra/convex`, and `@mastra/oracledb` storage adapters. It uses background agents for managing memory. When no model is set, the default model is `google/gemini-2.5-flash`.
 
 ## Temporal gap markers
 

package/.docs/docs/memory/semantic-recall.md

@@ -148,6 +148,7 @@ Each vector store page below includes installation instructions, configuration p
 - [libSQL](https://mastra.ai/reference/vectors/libsql)
 - [MongoDB](https://mastra.ai/reference/vectors/mongodb)
 - [OpenSearch](https://mastra.ai/reference/vectors/opensearch)
+- [OracleDB](https://mastra.ai/reference/vectors/oracledb)
 - [Pinecone](https://mastra.ai/reference/vectors/pinecone)
 - [PostgreSQL](https://mastra.ai/reference/vectors/pg)
 - [Qdrant](https://mastra.ai/reference/vectors/qdrant)
@@ -180,7 +181,7 @@ const agent = new Agent({
 })
 ```
 
-> **Note:** `scope: 'resource'` is supported by the LibSQL, PostgreSQL, MongoDB, and Upstash storage adapters.
+> **Note:** `scope: 'resource'` is supported by the LibSQL, OracleDB, PostgreSQL, MongoDB, and Upstash storage adapters.
 
 ### Metadata filtering
 

package/.docs/docs/memory/working-memory.md

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Working Memory
+# Working memory
 
 While [message history](https://mastra.ai/docs/memory/message-history) and [semantic recall](https://mastra.ai/docs/memory/semantic-recall) help agents remember conversations, working memory allows them to maintain persistent information about users across interactions.
 
@@ -129,6 +129,7 @@ Resource-scoped working memory requires specific storage adapters that support t
 
 - **libSQL** (`@mastra/libsql`)
 - **PostgreSQL** (`@mastra/pg`)
+- **OracleDB** (`@mastra/oracledb`)
 - **Upstash** (`@mastra/upstash`)
 - **MongoDB** (`@mastra/mongodb`)
 

package/.docs/docs/observability/integrations/exporters/mastra-storage.md

@@ -1,12 +1,12 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Mastra Storage exporter
+# Storage exporter
 
 The `MastraStorageExporter` persists traces to your configured storage backend, making them accessible through Studio. It requires no external services.
 
 > **Note:** `MastraStorageExporter` was previously called `DefaultExporter`. The original `DefaultExporter` class is still exported from `@mastra/observability` for backward compatibility, but it's deprecated. New code should use `MastraStorageExporter`.
 
-> **Production Observability:** Observability data can quickly overwhelm general-purpose databases in production. For high-traffic applications, route the observability storage domain to [ClickHouse](https://mastra.ai/reference/storage/clickhouse) through [composite storage](https://mastra.ai/reference/storage/composite). See [Production Recommendations](#production-recommendations) for details.
+> **Production Observability:** Observability data can quickly overwhelm general-purpose databases in production. For high-traffic applications, route the observability storage domain to [ClickHouse](https://mastra.ai/integrations/databases/clickhouse) through [composite storage](https://mastra.ai/reference/storage/composite). See [Production Recommendations](#production-recommendations) for details.
 
 ## Configuration
 
@@ -116,24 +116,25 @@ If you set the strategy to `'auto'`, the `MastraStorageExporter` automatically s
 
 ### Providers with Observability Support
 
-| Storage Provider                                                 | Preferred Strategy | Supported Strategies            | Recommended Use                       |
-| ---------------------------------------------------------------- | ------------------ | ------------------------------- | ------------------------------------- |
-| **[ClickHouse](https://mastra.ai/reference/storage/clickhouse)** | insert-only        | insert-only                     | Production (high-volume)              |
-| **[PostgreSQL](https://mastra.ai/reference/storage/postgresql)** | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
-| **[MSSQL](https://mastra.ai/reference/storage/mssql)**           | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
-| **[MongoDB](https://mastra.ai/reference/storage/mongodb)**       | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
-| **[libSQL](https://mastra.ai/reference/storage/libsql)**         | batch-with-updates | batch-with-updates, insert-only | Default storage, good for development |
+| Storage Provider                                                      | Preferred Strategy | Supported Strategies            | Recommended Use                       |
+| --------------------------------------------------------------------- | ------------------ | ------------------------------- | ------------------------------------- |
+| **[ClickHouse](https://mastra.ai/integrations/databases/clickhouse)** | insert-only        | insert-only                     | Production (high-volume)              |
+| **[PostgreSQL](https://mastra.ai/integrations/databases/postgresql)** | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
+| **[MSSQL](https://mastra.ai/integrations/databases/mssql)**           | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
+| **[MongoDB](https://mastra.ai/integrations/databases/mongodb)**       | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
+| **[OracleDB](https://mastra.ai/integrations/databases/oracledb)**     | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
+| **[libSQL](https://mastra.ai/integrations/databases/libsql)**         | batch-with-updates | batch-with-updates, insert-only | Default storage, good for development |
 
 ### Providers without Observability Support
 
 The following storage providers **don't support** the observability domain. If you're using one of these providers and need observability, use [composite storage](https://mastra.ai/reference/storage/composite) to route observability data to a supported provider:
 
-- [Convex](https://mastra.ai/reference/storage/convex)
-- [DynamoDB](https://mastra.ai/reference/storage/dynamodb)
-- [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1)
-- [Cloudflare Durable Objects](https://mastra.ai/reference/storage/cloudflare)
-- [Upstash](https://mastra.ai/reference/storage/upstash)
-- [LanceDB](https://mastra.ai/reference/storage/lance)
+- [Convex](https://mastra.ai/integrations/databases/convex)
+- [DynamoDB](https://mastra.ai/integrations/databases/dynamodb)
+- [Cloudflare D1](https://mastra.ai/integrations/databases/cloudflare-d1)
+- [Cloudflare Durable Objects](https://mastra.ai/integrations/databases/cloudflare-kv)
+- [Upstash](https://mastra.ai/integrations/databases/upstash)
+- [LanceDB](https://mastra.ai/integrations/databases/lancedb)
 
 ### Strategy Benefits
 
@@ -147,7 +148,7 @@ Observability data grows quickly in production environments. A single agent inte
 
 ### Recommended: ClickHouse for High-Volume Production
 
-[ClickHouse](https://mastra.ai/reference/storage/clickhouse) is a columnar database designed for high-volume analytics workloads. It's the recommended choice for production observability because:
+[ClickHouse](https://mastra.ai/integrations/databases/clickhouse) is a columnar database designed for high-volume analytics workloads. It's the recommended choice for production observability because:
 
 - **Optimized for writes**: Handles millions of inserts per second
 - **Efficient compression**: Reduces storage costs for trace data
@@ -241,6 +242,6 @@ new MastraStorageExporter({
 ## Related
 
 - [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview)
-- [MastraPlatformExporter](https://mastra.ai/docs/observability/integrations/exporters/mastra-platform)
+- [MastraPlatformExporter](https://mastra.ai/docs/mastra-platform/observability)
 - [Composite Storage](https://mastra.ai/reference/storage/composite): Combine multiple storage providers
 - [Storage Configuration](https://mastra.ai/docs/storage/overview)

package/.docs/docs/observability/logging.md

@@ -10,7 +10,7 @@ When deploying to the Mastra platform, logs are shown in the dashboard. In self-
 
 ## Configuring logs with `PinoLogger`
 
-When [initializing a new Mastra project](https://mastra.ai/guides/getting-started/quickstart) using the CLI, `PinoLogger` is included by default.
+When [initializing a new Mastra project](https://mastra.ai/docs) using the CLI, `PinoLogger` is included by default.
 
 ```typescript
 import { Mastra } from '@mastra/core/mastra'

package/.docs/docs/observability/metrics/overview.md

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Metrics overview
+# Metrics
 
 Mastra automatically emits performance and usage metrics from traced execution. There's no manual instrumentation needed. Metrics are derived from spans as they complete.
 

package/.docs/docs/observability/overview.md

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Observability overview
+# Observability
 
 Mastra's observability system gives you visibility into every agent run, workflow step, tool call, and model interaction. Agent behavior depends on model responses, prompts, tools, memory, and workflow state, so observability helps you inspect runtime decisions from day one. It captures complementary signals that work together to help you understand what your application is doing and why.
 
@@ -10,7 +10,6 @@ Mastra's observability system gives you visibility into every agent run, workflo
 - [**Logging**](https://mastra.ai/docs/observability/logging): Forwards structured log entries from your application and Mastra internals to observability storage, correlated to traces automatically.
 - [**Metrics**](https://mastra.ai/docs/observability/metrics/overview): Extracts trace usage and cost data. No additional instrumentation is required.
 - [**Feedback**](https://mastra.ai/docs/observability/feedback): Stores ratings, comments, corrections, and other review signals linked to traces and spans.
-- [**Integrations**](https://mastra.ai/docs/observability/integrations/overview): Choose exporters, bridges, and span processors for Studio, hosted, or external observability workflows.
 
 ## When to use observability
 
@@ -121,8 +120,6 @@ An observability config usually contains:
 - `spanOutputProcessors`: Transformations that run before spans are exported.
 - `logging`: Log forwarding settings for observability storage.
 
-For destinations and processors, see [Integrations overview](https://mastra.ai/docs/observability/integrations/overview).
-
 ### Maintaining Studio access
 
 When you add external exporters, keep `MastraStorageExporter` for Studio observability and/or `MastraPlatformExporter` for hosted Mastra platform observability.
@@ -234,7 +231,6 @@ For hosted traces, logs, and metrics across projects and deploys, see [Observabi
 - [Logging](https://mastra.ai/docs/observability/logging)
 - [Metrics](https://mastra.ai/docs/observability/metrics/overview)
 - [Feedback](https://mastra.ai/docs/observability/feedback)
-- [Integrations overview](https://mastra.ai/docs/observability/integrations/overview)
 - [Mastra Studio](https://mastra.ai/docs/studio/observability)
 - [Automatic metrics reference](https://mastra.ai/reference/observability/metrics/automatic-metrics)
 - [Mastra platform observability](https://mastra.ai/docs/mastra-platform/observability)

package/.docs/docs/observability/tracing/overview.md

@@ -1,6 +1,6 @@
 > Discover all available pages from the documentation index: https://mastra.ai/llms.txt
 
-# Tracing
+# Traces
 
 Tracing is the observability signal that records how a request moves through agents, workflows, tools, and model calls. Mastra represents each operation as a span and groups related spans into a trace so you can inspect the full execution path.
 
@@ -21,7 +21,6 @@ To get started with tracing, configure observability in your Mastra instance and
 
 - [Configuration](https://mastra.ai/docs/observability/overview): Base observability config and multiple configs, plus serverless flushing
 - [Storage](https://mastra.ai/docs/observability/overview): Storage routing for traces, logs, and metrics
-- [Integrations overview](https://mastra.ai/docs/observability/integrations/overview): Exporters, bridges, and processors
 
 ## Sampling strategies
 
@@ -333,7 +332,7 @@ const result = await agent.generate([{ role: 'user', content: 'Sensitive operati
 })
 ```
 
-For more fine-grained control over sensitive data, consider using the [Sensitive Data Filter](https://mastra.ai/docs/observability/integrations/processors/sensitive-data-filter) processor, which can redact specific fields (like passwords, tokens, and keys) while preserving the rest of the input/output.
+For more fine-grained control over sensitive data, consider using the [Sensitive Data Filter](https://mastra.ai/reference/observability/tracing/processors/sensitive-data-filter) processor, which can redact specific fields (like passwords, tokens, and keys) while preserving the rest of the input/output.
 
 #### Child spans and metadata extraction
 
@@ -423,7 +422,7 @@ Span processors transform, filter, or enrich trace data before it's exported. Th
 
 #### Built-in processors
 
-- [Sensitive Data Filter](https://mastra.ai/docs/observability/integrations/processors/sensitive-data-filter) redacts sensitive information. It's enabled in the default observability config.
+- [Sensitive Data Filter](https://mastra.ai/reference/observability/tracing/processors/sensitive-data-filter) redacts sensitive information. It's enabled in the default observability config.
 
 #### Creating custom processors
 
@@ -466,8 +465,6 @@ Processors are executed in the order they're defined, allowing you to chain mult
 - Normalizing data formats
 - Enriching spans with business context
 
-For the broader exporter, bridge, and processor model, see [Integrations overview](https://mastra.ai/docs/observability/integrations/overview).
-
 ## Span filtering
 
 Span filtering lets you reduce noise and per-span costs before data reaches your observability platform. Configure it per observability instance, so different exporters or environments can keep different levels of detail.