@mastra/mcp-docs-server 1.0.0-beta.13 → 1.0.0-beta.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "1.0.0-beta.13",
+  "version": "1.0.0-beta.14",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -28,8 +28,8 @@
     "@modelcontextprotocol/sdk": "^1.17.5",
     "jsdom": "^26.1.0",
     "zod": "^3.25.76",
-    "@mastra/core": "1.0.0-beta.13",
-    "@mastra/mcp": "^1.0.0-beta.6"
+    "@mastra/mcp": "^1.0.0-beta.6",
+    "@mastra/core": "1.0.0-beta.14"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.6",
@@ -46,7 +46,7 @@
     "typescript": "^5.8.3",
     "vitest": "4.0.12",
     "@internal/lint": "0.0.53",
-    "@mastra/core": "1.0.0-beta.13"
+    "@mastra/core": "1.0.0-beta.14"
   },
   "homepage": "https://mastra.ai",
   "repository": {

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 | Storage"
-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 | Storage"
-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 | Storage"
-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 | Storage"
-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);
-}
-```
-