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

package/.docs/raw/deployment/mastra-cloud/setting-up.mdx

@@ -1,105 +0,0 @@
----
-title: "Setting Up and Deploying | Mastra Cloud"
-description: Configuration steps for Mastra Cloud projects
----
-
-import { MastraCloudCallout } from "@site/src/components/MastraCloudCallout";
-import Steps from "@site/src/components/Steps";
-import StepItem from "@site/src/components/StepItem";
-
-# Setting Up and Deploying
-
-This page explains how to set up a project on [Mastra Cloud](https://mastra.ai/cloud) with automatic deployments using our GitHub integration.
-
-<MastraCloudCallout />
-
-## Prerequisites
-
-- A [Mastra Cloud](https://mastra.ai/cloud) account
-- A GitHub account / repository containing a Mastra application
-
-> See our [Getting started](/guides/v1/getting-started/quickstart) guide to scaffold out a new Mastra project with sensible defaults.
-
-## Setup and Deploy process
-
-<Steps>
-
-<StepItem>
-
-Head over to [https://cloud.mastra.ai/](https://cloud.mastra.ai) and sign in with either:
-
-- **GitHub**
-- **Google**
-
-</StepItem>
-
-<StepItem>
-
-When prompted, install the Mastra GitHub app.
-
-![Install GitHub](/img/mastra-cloud/mastra-cloud-install-github.jpg)
-
-</StepItem>
-
-<StepItem>
-
-Click the **Create new project** button to create a new project.
-
-![Create new project](/img/mastra-cloud/mastra-cloud-create-new-project.jpg)
-
-</StepItem>
-
-<StepItem>
-
-Search for a repository, then click **Import**.
-
-![Import Git repository](/img/mastra-cloud/mastra-cloud-import-git-repository.jpg)
-
-</StepItem>
-
-<StepItem>
-
-Mastra Cloud automatically detects the right build settings, but you can customize them using the options described below.
-
-![Deployment details](/img/mastra-cloud/mastra-cloud-deployment-details.jpg)
-
-- **Importing from GitHub**: The GitHub repository name
-- **Project name**: Customize the project name
-- **Branch**: The branch to deploy from
-- **Project root**: The root directory of your project
-- **Mastra directory**: Where Mastra files are located
-- **Environment variables**: Add environment variables used by the application
-- **Build and Store settings**:
-  - **Install command**: Runs pre-build to install project dependencies
-  - **Project setup command**: Runs pre-build to prepare any external dependencies
-  - **Port**: The network port the server will use
-  - **Store settings**: Use Mastra Cloud's built-in [LibSQLStore](/docs/v1/server-db/storage) storage
-- **Deploy Project**: Starts the deployment process
-
-</StepItem>
-
-<StepItem>
-
-Click **Deploy Project** to create and deploy your application using the configuration you've set.
-
-</StepItem>
-
-</Steps>
-
-## Successful deployment
-
-After a successful deployment you'll be shown the **Overview** screen where you can view your project's status, domains, latest deployments and connected agents and workflows.
-
-![Successful deployment](/img/mastra-cloud/mastra-cloud-successful-deployment.jpg)
-
-## Continuous integration
-
-Your project is now configured with automatic deployments which occur whenever you push to the configured branch of your GitHub repository.
-
-## Testing your application
-
-After a successful deployment you can test your agents and workflows [Studio](/docs/v1/deployment/mastra-cloud/dashboard#studio) in Mastra Cloud, or interact with them using our [Client SDK](/docs/v1/server-db/mastra-client).
-
-## Next steps
-
-- [Navigating the Dashboard](/docs/v1/deployment/mastra-cloud/dashboard)

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

@@ -1,24 +0,0 @@
----
-title: "Conversation History | Memory"
-description: "Learn how to configure conversation history in Mastra to store recent messages from the current conversation."
----
-
-# Conversation History
-
-Conversation history is the simplest kind of memory. It is a list of messages from the current conversation.
-
-By default, each request includes the last 10 messages from the current memory thread, giving the agent short-term conversational context. This limit can be increased using the `lastMessages` parameter.
-
-You can increase this limit by passing the `lastMessages` parameter to the `Memory` instance.
-
-```typescript {3-7} showLineNumbers
-export const testAgent = new Agent({
-  id: "test-agent",
-  // ...
-  memory: new Memory({
-    options: {
-      lastMessages: 20,
-    },
-  }),
-});
-```

package/.docs/raw/memory/storage/memory-with-libsql.mdx

@@ -1,140 +0,0 @@
----
-title: "Memory with LibSQL | Memory"
-description: Example for how to use Mastra's memory system with LibSQL storage and vector database backend.
----
-
-# Memory with LibSQL
-
-This example demonstrates how to use Mastra's memory system with LibSQL as the storage backend.
-
-## Prerequisites
-
-This example uses the `openai` model. Make sure to add `OPENAI_API_KEY` to your `.env` file.
-
-```bash title=".env" copy
-OPENAI_API_KEY=<your-api-key>
-```
-
-And install the following package:
-
-```bash copy
-npm install @mastra/libsql@beta
-```
-
-## Adding memory to an agent
-
-To add LibSQL memory to an agent use the `Memory` class and create a new `storage` key using `LibSQLStore`. The `url` can either by a remote location, or a local file system resource.
-
-```typescript title="src/mastra/agents/example-libsql-agent.ts" showLineNumbers copy
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-import { LibSQLStore } from "@mastra/libsql";
-
-export const libsqlAgent = new Agent({
-  id: "libsql-agent",
-  name: "LibSQL Agent",
-  instructions:
-    "You are an AI agent with the ability to automatically recall memories from previous interactions.",
-  model: "openai/gpt-5.1",
-  memory: new Memory({
-    storage: new LibSQLStore({
-      id: 'libsql-agent-storage',
-      url: "file:libsql-agent.db",
-    }),
-    options: {
-      generateTitle: true, // Explicitly enable automatic title generation
-    },
-  }),
-});
-```
-
-## Local embeddings with fastembed
-
-Embeddings are numeric vectors used by memory’s `semanticRecall` to retrieve related messages by meaning (not keywords). This setup uses `@mastra/fastembed` to generate vector embeddings.
-
-Install `fastembed` to get started:
-
-```bash copy
-npm install @mastra/fastembed@beta
-```
-
-Add the following to your agent:
-
-```typescript title="src/mastra/agents/example-libsql-agent.ts" showLineNumbers copy
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
-import { fastembed } from "@mastra/fastembed";
-
-export const libsqlAgent = new Agent({
-  id: "libsql-agent",
-  name: "LibSQL Agent",
-  instructions:
-    "You are an AI agent with the ability to automatically recall memories from previous interactions.",
-  model: "openai/gpt-5.1",
-  memory: new Memory({
-    storage: new LibSQLStore({
-      id: 'libsql-agent-storage',
-      url: "file:libsql-agent.db",
-    }),
-    vector: new LibSQLVector({
-      id: 'libsql-agent-vector',
-      connectionUrl: "file:libsql-agent.db",
-    }),
-    embedder: fastembed,
-    options: {
-      lastMessages: 10,
-      semanticRecall: {
-        topK: 3,
-        messageRange: 2,
-      },
-      threads: {
-        generateTitle: true, // Explicitly enable automatic title generation
-      },
-    },
-  }),
-});
-```
-
-## Usage example
-
-Use `memoryOptions` to scope recall for this request. Set `lastMessages: 5` to limit recency-based recall, and use `semanticRecall` to fetch the `topK: 3` most relevant messages, including `messageRange: 2` neighboring messages for context around each match.
-
-```typescript title="src/test-libsql-agent.ts" showLineNumbers copy
-import "dotenv/config";
-
-import { mastra } from "./mastra";
-
-const threadId = "123";
-const resourceId = "user-456";
-
-const agent = mastra.getAgent("libsqlAgent");
-
-const message = await agent.stream("My name is Mastra", {
-  memory: {
-    thread: threadId,
-    resource: resourceId,
-  },
-});
-
-await message.textStream.pipeTo(new WritableStream());
-
-const stream = await agent.stream("What's my name?", {
-  memory: {
-    thread: threadId,
-    resource: resourceId,
-  },
-  memoryOptions: {
-    lastMessages: 5,
-    semanticRecall: {
-      topK: 3,
-      messageRange: 2,
-    },
-  },
-});
-
-for await (const chunk of stream.textStream) {
-  process.stdout.write(chunk);
-}
-```
-

package/.docs/raw/memory/storage/memory-with-mongodb.mdx

@@ -1,150 +0,0 @@
----
-title: "Example: Memory with MongoDB | Memory"
-description: Example for how to use Mastra's memory system with MongoDB storage and vector capabilities.
----
-
-# Memory with MongoDB
-
-This example demonstrates how to use Mastra's memory system with MongoDB as the storage backend.
-
-## Prerequisites
-
-This example uses the `openai` model and requires a MongoDB database. Make sure to add the following to your `.env` file:
-
-```bash title=".env" copy
-OPENAI_API_KEY=<your-api-key>
-MONGODB_URI=<your-connection-string>
-MONGODB_DB_NAME=<your-db-name>
-```
-
-And install the following package:
-
-```bash copy
-npm install @mastra/mongodb@beta
-```
-
-## Adding memory to an agent
-
-To add MongoDB memory to an agent use the `Memory` class and create a new `storage` key using `MongoDBStore`. The configuration supports both local and remote MongoDB instances.
-
-```typescript title="src/mastra/agents/example-mongodb-agent.ts" showLineNumbers copy
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-import { MongoDBStore } from "@mastra/mongodb";
-
-export const mongodbAgent = new Agent({
-  id: "mongodb-agent",
-  name: "mongodb-agent",
-  instructions:
-    "You are an AI agent with the ability to automatically recall memories from previous interactions.",
-  model: "openai/gpt-5.1",
-  memory: new Memory({
-    storage: new MongoDBStore({
-      url: process.env.MONGODB_URI!,
-      dbName: process.env.MONGODB_DB_NAME!,
-    }),
-    options: {
-      threads: {
-        generateTitle: true,
-      },
-    },
-  }),
-});
-```
-
-## Vector embeddings with MongoDB
-
-Embeddings are numeric vectors used by memory's `semanticRecall` to retrieve related messages by meaning (not keywords).
-
-> Note: You must use a deployment hosted on MongoDB Atlas to successfully use the MongoDB Vector database.
-
-This setup uses FastEmbed, a local embedding model, to generate vector embeddings.
-To use this, install `@mastra/fastembed`:
-
-```bash copy
-npm install @mastra/fastembed@beta
-```
-
-Add the following to your agent:
-
-```typescript title="src/mastra/agents/example-mongodb-agent.ts" showLineNumbers copy
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-import { MongoDBStore, MongoDBVector } from "@mastra/mongodb";
-import { fastembed } from "@mastra/fastembed";
-
-export const mongodbAgent = new Agent({
-  id: "mongodb-agent",
-  name: "mongodb-agent",
-  instructions:
-    "You are an AI agent with the ability to automatically recall memories from previous interactions.",
-  model: "openai/gpt-5.1",
-  memory: new Memory({
-    storage: new MongoDBStore({
-      url: process.env.MONGODB_URI!,
-      dbName: process.env.MONGODB_DB_NAME!,
-    }),
-    vector: new MongoDBVector({
-      uri: process.env.MONGODB_URI!,
-      dbName: process.env.MONGODB_DB_NAME!,
-    }),
-    embedder: fastembed,
-    options: {
-      lastMessages: 10,
-      semanticRecall: {
-        topK: 3,
-        messageRange: 2,
-      },
-      threads: {
-        generateTitle: true, // generates descriptive thread titles automatically
-      },
-    },
-  }),
-});
-```
-
-## Usage example
-
-Use `memoryOptions` to scope recall for this request. Set `lastMessages: 5` to limit recency-based recall, and use `semanticRecall` to fetch the `topK: 3` most relevant messages, including `messageRange: 2` neighboring messages for context around each match.
-
-```typescript title="src/test-mongodb-agent.ts" showLineNumbers copy
-import "dotenv/config";
-
-import { mastra } from "./mastra";
-
-const threadId = "123";
-const resourceId = "user-456";
-
-const agent = mastra.getAgent("mongodbAgent");
-
-const message = await agent.stream("My name is Mastra", {
-  memory: {
-    thread: threadId,
-    resource: resourceId,
-  },
-});
-
-await message.textStream.pipeTo(new WritableStream());
-
-const stream = await agent.stream("What's my name?", {
-  memory: {
-    thread: threadId,
-    resource: resourceId,
-  },
-  memoryOptions: {
-    lastMessages: 5,
-    semanticRecall: {
-      topK: 3,
-      messageRange: 2,
-    },
-  },
-});
-
-for await (const chunk of stream.textStream) {
-  process.stdout.write(chunk);
-}
-```
-
-## Related
-
-- [Calling Agents](/docs/v1/agents/overview)

package/.docs/raw/memory/storage/memory-with-pg.mdx

@@ -1,138 +0,0 @@
----
-title: "Memory with Postgres | Memory"
-description: Example for how to use Mastra's memory system with PostgreSQL storage and vector capabilities.
----
-
-# Memory with Postgres
-
-This example demonstrates how to use Mastra's memory system with PostgreSQL as the storage backend.
-
-## Prerequisites
-
-This example uses the `openai` model and requires a PostgreSQL database with the `pgvector` extension. Make sure to add the following to your `.env` file:
-
-```bash title=".env" copy
-OPENAI_API_KEY=<your-api-key>
-DATABASE_URL=<your-connection-string>
-```
-
-And install the following package:
-
-```bash copy
-npm install @mastra/pg@beta
-```
-
-## Adding memory to an agent
-
-To add PostgreSQL memory to an agent use the `Memory` class and create a new `storage` key using `PostgresStore`. The `connectionString` can either be a remote location, or a local database connection.
-
-```typescript title="src/mastra/agents/example-pg-agent.ts" showLineNumbers copy
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-import { PostgresStore } from "@mastra/pg";
-
-export const pgAgent = new Agent({
-  id: "pg-agent",
-  name: "PG Agent",
-  instructions:
-    "You are an AI agent with the ability to automatically recall memories from previous interactions.",
-  model: "openai/gpt-5.1",
-  memory: new Memory({
-    storage: new PostgresStore({
-      id: 'pg-agent-storage',
-      connectionString: process.env.DATABASE_URL!,
-    }),
-    options: {
-      generateTitle: true, // Explicitly enable automatic title generation
-    },
-  }),
-});
-```
-
-## Local embeddings with fastembed
-
-Embeddings are numeric vectors used by memory’s `semanticRecall` to retrieve related messages by meaning (not keywords). This setup uses `@mastra/fastembed` to generate vector embeddings.
-
-Install `fastembed` to get started:
-
-```bash copy
-npm install @mastra/fastembed@beta
-```
-
-Add the following to your agent:
-
-```typescript title="src/mastra/agents/example-pg-agent.ts" showLineNumbers copy
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-import { PostgresStore, PgVector } from "@mastra/pg";
-import { fastembed } from "@mastra/fastembed";
-
-export const pgAgent = new Agent({
-  id: "pg-agent",
-  name: "PG Agent",
-  instructions:
-    "You are an AI agent with the ability to automatically recall memories from previous interactions.",
-  model: "openai/gpt-5.1",
-  memory: new Memory({
-    storage: new PostgresStore({
-      id: 'pg-agent-storage',
-      connectionString: process.env.DATABASE_URL!,
-    }),
-    vector: new PgVector({
-      id: 'pg-agent-vector',
-      connectionString: process.env.DATABASE_URL!,
-    }),
-    embedder: fastembed,
-    options: {
-      lastMessages: 10,
-      semanticRecall: {
-        topK: 3,
-        messageRange: 2,
-      },
-    },
-  }),
-});
-```
-
-## Usage example
-
-Use `memoryOptions` to scope recall for this request. Set `lastMessages: 5` to limit recency-based recall, and use `semanticRecall` to fetch the `topK: 3` most relevant messages, including `messageRange: 2` neighboring messages for context around each match.
-
-```typescript title="src/test-pg-agent.ts" showLineNumbers copy
-import "dotenv/config";
-
-import { mastra } from "./mastra";
-
-const threadId = "123";
-const resourceId = "user-456";
-
-const agent = mastra.getAgent("pgAgent");
-
-const message = await agent.stream("My name is Mastra", {
-  memory: {
-    thread: threadId,
-    resource: resourceId,
-  },
-});
-
-await message.textStream.pipeTo(new WritableStream());
-
-const stream = await agent.stream("What's my name?", {
-  memory: {
-    thread: threadId,
-    resource: resourceId,
-  },
-  memoryOptions: {
-    lastMessages: 5,
-    semanticRecall: {
-      topK: 3,
-      messageRange: 2,
-    },
-  },
-});
-
-for await (const chunk of stream.textStream) {
-  process.stdout.write(chunk);
-}
-```
-

package/.docs/raw/memory/storage/memory-with-upstash.mdx

@@ -1,146 +0,0 @@
----
-title: "Memory with Upstash | Memory"
-description: Example for how to use Mastra's memory system with Upstash Redis storage and vector capabilities.
----
-
-# Memory with Upstash
-
-This example demonstrates how to use Mastra's memory system with Upstash as the storage backend.
-
-## Prerequisites
-
-This example uses the `openai` model and requires both Upstash Redis and Upstash Vector services. Make sure to add the following to your `.env` file:
-
-```bash title=".env" copy
-OPENAI_API_KEY=<your-api-key>
-UPSTASH_REDIS_REST_URL=<your-redis-url>
-UPSTASH_REDIS_REST_TOKEN=<your-redis-token>
-UPSTASH_VECTOR_REST_URL=<your-vector-index-url>
-UPSTASH_VECTOR_REST_TOKEN=<your-vector-index-token>
-```
-
-You can get your Upstash credentials by signing up at [upstash.com](https://upstash.com) and creating both Redis and Vector databases.
-
-And install the following package:
-
-```bash copy
-npm install @mastra/upstash@beta
-```
-
-## Adding memory to an agent
-
-To add Upstash memory to an agent use the `Memory` class and create a new `storage` key using `UpstashStore` and a new `vector` key using `UpstashVector`. The configuration can point to either a remote service or a local setup.
-
-```typescript title="src/mastra/agents/example-upstash-agent.ts" showLineNumbers copy
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-import { UpstashStore } from "@mastra/upstash";
-
-export const upstashAgent = new Agent({
-  id: "upstash-agent",
-  name: "Upstash Agent",
-  instructions:
-    "You are an AI agent with the ability to automatically recall memories from previous interactions.",
-  model: "openai/gpt-5.1",
-  memory: new Memory({
-    storage: new UpstashStore({
-      id: 'upstash-agent-storage',
-      url: process.env.UPSTASH_REDIS_REST_URL!,
-      token: process.env.UPSTASH_REDIS_REST_TOKEN!,
-    }),
-    options: {
-      generateTitle: true, // Explicitly enable automatic title generation
-    },
-  }),
-});
-```
-
-## Local embeddings with fastembed
-
-Embeddings are numeric vectors used by memory’s `semanticRecall` to retrieve related messages by meaning (not keywords). This setup uses `@mastra/fastembed` to generate vector embeddings.
-
-Install `fastembed` to get started:
-
-```bash copy
-npm install @mastra/fastembed@beta
-```
-
-Add the following to your agent:
-
-```typescript title="src/mastra/agents/example-upstash-agent.ts" showLineNumbers copy
-import { Memory } from "@mastra/memory";
-import { Agent } from "@mastra/core/agent";
-import { UpstashStore, UpstashVector } from "@mastra/upstash";
-import { fastembed } from "@mastra/fastembed";
-
-export const upstashAgent = new Agent({
-  id: "upstash-agent",
-  name: "Upstash Agent",
-  instructions:
-    "You are an AI agent with the ability to automatically recall memories from previous interactions.",
-  model: "openai/gpt-5.1",
-  memory: new Memory({
-    storage: new UpstashStore({
-      id: 'upstash-agent-storage',
-      url: process.env.UPSTASH_REDIS_REST_URL!,
-      token: process.env.UPSTASH_REDIS_REST_TOKEN!,
-    }),
-    vector: new UpstashVector({
-      id: 'upstash-agent-vector',
-      url: process.env.UPSTASH_VECTOR_REST_URL!,
-      token: process.env.UPSTASH_VECTOR_REST_TOKEN!,
-    }),
-    embedder: fastembed,
-    options: {
-      lastMessages: 10,
-      semanticRecall: {
-        topK: 3,
-        messageRange: 2,
-      },
-    },
-  }),
-});
-```
-
-## Usage example
-
-Use `memoryOptions` to scope recall for this request. Set `lastMessages: 5` to limit recency-based recall, and use `semanticRecall` to fetch the `topK: 3` most relevant messages, including `messageRange: 2` neighboring messages for context around each match.
-
-```typescript title="src/test-upstash-agent.ts" showLineNumbers copy
-import "dotenv/config";
-
-import { mastra } from "./mastra";
-
-const threadId = "123";
-const resourceId = "user-456";
-
-const agent = mastra.getAgent("upstashAgent");
-
-const message = await agent.stream("My name is Mastra", {
-  memory: {
-    thread: threadId,
-    resource: resourceId,
-  },
-});
-
-await message.textStream.pipeTo(new WritableStream());
-
-const stream = await agent.stream("What's my name?", {
-  memory: {
-    thread: threadId,
-    resource: resourceId,
-  },
-  memoryOptions: {
-    lastMessages: 5,
-    semanticRecall: {
-      topK: 3,
-      messageRange: 2,
-    },
-  },
-});
-
-for await (const chunk of stream.textStream) {
-  process.stdout.write(chunk);
-}
-```
-