@mastra/mcp-docs-server 0.13.7-alpha.0 → 0.13.7-alpha.2

package/.docs/raw/reference/agents/agent.mdx

@@ -61,6 +61,13 @@ constructor(config: AgentConfig<TAgentId, TTools, TMetrics>)
       description:
         "Tools that the agent can use. Can be a static object or a function that returns tools.",
     },
+    {
+      name: "inputProcessors",
+      type: "InputProcessor[] | ({ runtimeContext: RuntimeContext }) => InputProcessor[] | Promise<InputProcessor[]>",
+      isOptional: true,
+      description:
+        "Input processors that run sequentially before messages are sent to the language model. These middleware components can intercept, modify, validate, or filter messages. Each processor receives an array of MastraMessageV2 objects and an abort function for early termination. Can be a static array or a function that returns processors based on runtime context.",
+    },
     {
       name: "defaultGenerateOptions",
       type: "AgentGenerateOptions",

package/.docs/raw/reference/agents/generate.mdx

@@ -16,16 +16,27 @@ The `messages` parameter can be:
 - A single string
 - An array of strings
 - An array of message objects with `role` and `content` properties
+- An array of `UIMessageWithMetadata` objects (for messages with metadata)
 
-The message object structure:
+The message object structures:
 
 ```typescript
 interface Message {
   role: "system" | "user" | "assistant";
   content: string;
 }
+
+// For messages with metadata
+interface UIMessageWithMetadata {
+  role: "user" | "assistant";
+  content: string;
+  parts: Array<{ type: string; text?: string; [key: string]: any }>;
+  metadata?: Record<string, unknown>; // Optional metadata field
+}
 ```
 
+When using `UIMessageWithMetadata`, the metadata will be preserved throughout the conversation and stored with the messages in memory.
+
 ### `options` (Optional)
 
 An optional object that can include configuration for output structure, memory management, tool usage, telemetry, and more.
@@ -175,6 +186,12 @@ An optional object that can include configuration for output structure, memory m
       description:
         "Tools that are executed on the 'client' side of the request. These tools do not have execute functions in the definition.",
     },
+    {
+      name: "savePerStep",
+      type: "boolean",
+      isOptional: true,
+      description: "Save messages incrementally after each stream step completes (default: false).",
+    }
   ]}
 />
 

package/.docs/raw/reference/agents/stream.mdx

@@ -16,16 +16,27 @@ The `messages` parameter can be:
 - A single string
 - An array of strings
 - An array of message objects with `role` and `content` properties
+- An array of `UIMessageWithMetadata` objects (for messages with metadata)
 
-The message object structure:
+The message object structures:
 
 ```typescript
 interface Message {
   role: "system" | "user" | "assistant";
   content: string;
 }
+
+// For messages with metadata
+interface UIMessageWithMetadata {
+  role: "user" | "assistant";
+  content: string;
+  parts: Array<{ type: string; text?: string; [key: string]: any }>;
+  metadata?: Record<string, unknown>; // Optional metadata field
+}
 ```
 
+When using `UIMessageWithMetadata`, the metadata will be preserved throughout the conversation and stored with the messages in memory.
+
 ### `options` (Optional)
 
 An optional object that can include configuration for output structure, memory management, tool usage, telemetry, and more.
@@ -181,6 +192,12 @@ An optional object that can include configuration for output structure, memory m
       description:
         "Tools that are executed on the 'client' side of the request. These tools do not have execute functions in the definition.",
     },
+    {
+      name: "savePerStep",
+      type: "boolean",
+      isOptional: true,
+      description: "Save messages incrementally after each generation step completes (default: false)",
+    }
   ]}
 />
 

package/.docs/raw/reference/cli/dev.mdx

@@ -60,6 +60,12 @@ mastra dev [options]
       description: "Start the dev server in inspect mode and break at the beginning of the script (cannot be used with --inspect)",
       isOptional: true,
     },
+    {
+      name: "--custom-args",
+      type: "string",
+      description: "Comma-separated list of custom arguments to pass to the dev server. IE: --experimental-transform-types",
+      isOptional: true,
+    },
     {
       name: "--help",
       type: "boolean",

package/.docs/raw/reference/client-js/memory.mdx

@@ -103,6 +103,24 @@ const { messages } = await thread.getMessages();
 const { messages } = await thread.getMessages({ limit: 10 });
 ```
 
+### Delete a Message
+
+Delete a specific message from a thread:
+
+```typescript
+const result = await thread.deleteMessage("message-id");
+// Returns: { success: true, message: "Message deleted successfully" }
+```
+
+### Delete Multiple Messages
+
+Delete multiple messages from a thread in a single operation:
+
+```typescript
+const result = await thread.deleteMessages(["message-1", "message-2", "message-3"]);
+// Returns: { success: true, message: "3 messages deleted successfully" }
+```
+
 ### Get Memory Status
 
 Check the status of the memory system:

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

@@ -126,7 +126,7 @@ The constructor accepts an optional `Config` object to customize its behavior an
         "Server configuration including port, host, timeout, API routes, middleware, CORS settings, and build options for Swagger UI, API request logging, and OpenAPI docs.",
       isOptional: true,
       defaultValue:
-        "{ port: 4111, host: localhost,  cors: { origin: '*', allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'], allowHeaders: ['Content-Type', 'Authorization', 'x-mastra-client-type'], exposeHeaders: ['Content-Length', 'X-Requested-With'], credentials: false } }",
+        "{ port: 4111, host: localhost,  cors: { origin: '*', allowMethods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'], allowHeaders: ['Content-Type', 'Authorization', 'x-mastra-client-type'], exposeHeaders: ['Content-Length', 'X-Requested-With'], credentials: false } }",
     },
     {
       name: "mcpServers",

package/.docs/raw/reference/memory/Memory.mdx

@@ -310,3 +310,4 @@ Mastra supports many embedding models through the [Vercel AI SDK](https://sdk.ve
 - [query](/reference/memory/query.mdx)
 - [getThreadById](/reference/memory/getThreadById.mdx)
 - [getThreadsByResourceId](/reference/memory/getThreadsByResourceId.mdx)
+- [deleteMessages](/reference/memory/deleteMessages.mdx)

package/.docs/raw/reference/memory/deleteMessages.mdx

@@ -0,0 +1,95 @@
+---
+section: Memory
+title: deleteMessages
+slug: reference/memory/deleteMessages
+categorySlug: reference
+layout: guide
+---
+
+# `deleteMessages`
+
+Deletes one or more messages from the memory storage. This method accepts arrays to delete multiple messages in a single operation.
+
+## Syntax
+
+```typescript
+memory.deleteMessages(input: MessageDeleteInput): Promise<void>
+
+type MessageDeleteInput = 
+  | string[]                  // Array of message IDs
+  | { id: string }[]         // Array of message objects
+```
+
+## Parameters
+
+- `input` (required): An array of messages to delete. Must be either:
+  - An array of message IDs (strings)
+  - An array of message objects with `id` properties
+
+## Returns
+
+A Promise that resolves when all messages have been successfully deleted.
+
+## Examples
+
+### Delete a single message
+
+```typescript
+// Using an array with a single string ID
+await memory.deleteMessages(['msg-123']);
+
+// Using an array with a single message object
+await memory.deleteMessages([{ id: 'msg-123' }]);
+```
+
+### Delete multiple messages
+
+```typescript
+// Using an array of string IDs
+await memory.deleteMessages(['msg-1', 'msg-2', 'msg-3']);
+
+// Using an array of message objects
+await memory.deleteMessages([
+  { id: 'msg-1' },
+  { id: 'msg-2' },
+  { id: 'msg-3' }
+]);
+```
+
+### Using with client SDK
+
+```typescript
+// Get a thread instance
+const thread = client.getAgent('my-agent').getThread('thread-123');
+
+// Delete a single message
+await thread.deleteMessages(['msg-123']);
+
+// Delete multiple messages
+await thread.deleteMessages(['msg-1', 'msg-2', 'msg-3']);
+
+// Delete using message objects (useful when you have message data)
+const messagesToDelete = messages.map(msg => ({ id: msg.id }));
+await thread.deleteMessages(messagesToDelete);
+```
+
+### Error handling
+
+```typescript
+try {
+  await memory.deleteMessages(['msg-1', 'msg-2', 'msg-3']);
+  console.log('Messages deleted successfully');
+} catch (error) {
+  console.error('Failed to delete messages:', error);
+}
+```
+
+## Notes
+
+- This method requires an array as input, even when deleting a single message
+- Thread timestamps are automatically updated when messages are deleted
+- The method automatically extracts message IDs from message objects
+- All message IDs must be non-empty strings
+- An empty array will result in no operation (no error thrown)
+- Messages from different threads can be deleted in the same operation
+- When using message objects, only the `id` property is required

package/.docs/raw/reference/memory/getThreadsByResourceId.mdx

@@ -1,6 +1,6 @@
 # getThreadsByResourceId Reference
 
-The `getThreadsByResourceId` function retrieves all threads associated with a specific resource ID from storage.
+The `getThreadsByResourceId` function retrieves all threads associated with a specific resource ID from storage. Threads can be sorted by creation or modification time in ascending or descending order.
 
 ## Usage Example
 
@@ -9,9 +9,17 @@ import { Memory } from "@mastra/core/memory";
 
 const memory = new Memory(config);
 
+// Basic usage - returns threads sorted by createdAt DESC (default)
 const threads = await memory.getThreadsByResourceId({
   resourceId: "resource-123",
 });
+
+// Custom sorting by updatedAt in ascending order
+const threadsByUpdate = await memory.getThreadsByResourceId({
+  resourceId: "resource-123",
+  orderBy: "updatedAt",
+  sortDirection: "ASC",
+});
 ```
 
 ## Parameters
@@ -24,9 +32,33 @@ const threads = await memory.getThreadsByResourceId({
       description: "The ID of the resource whose threads are to be retrieved.",
       isOptional: false,
     },
+    {
+      name: "orderBy",
+      type: "ThreadOrderBy",
+      description: "Field to sort threads by. Accepts 'createdAt' or 'updatedAt'. Default: 'createdAt'",
+      isOptional: true,
+    },
+    {
+      name: "sortDirection",
+      type: "ThreadSortDirection", 
+      description: "Sort order direction. Accepts 'ASC' or 'DESC'. Default: 'DESC'",
+      isOptional: true,
+    },
   ]}
 />
 
+## Type Definitions
+
+```typescript
+type ThreadOrderBy = 'createdAt' | 'updatedAt';
+type ThreadSortDirection = 'ASC' | 'DESC';
+
+interface ThreadSortOptions {
+  orderBy?: ThreadOrderBy;
+  sortDirection?: ThreadSortDirection;
+}
+```
+
 ## Returns
 
 <PropertiesTable

package/.docs/raw/reference/rag/upstash.mdx

@@ -5,7 +5,7 @@ description: Documentation for the UpstashVector class in Mastra, which provides
 
 # Upstash Vector Store
 
-The UpstashVector class provides vector search using [Upstash Vector](https://upstash.com/vector), a serverless vector database service that provides vector similarity search with metadata filtering capabilities.
+The UpstashVector class provides vector search using [Upstash Vector](https://upstash.com/vector), a serverless vector database service that provides vector similarity search with metadata filtering capabilities and hybrid search support.
 
 ## Constructor Options
 
@@ -66,6 +66,12 @@ Note: This method is a no-op for Upstash as indexes are created automatically.
       type: "number[][]",
       description: "Array of embedding vectors",
     },
+    {
+      name: "sparseVectors",
+      type: "{ indices: number[], values: number[] }[]",
+      isOptional: true,
+      description: "Array of sparse vectors for hybrid search. Each sparse vector must have matching indices and values arrays.",
+    },
     {
       name: "metadata",
       type: "Record<string, any>[]",
@@ -95,6 +101,12 @@ Note: This method is a no-op for Upstash as indexes are created automatically.
       type: "number[]",
       description: "Query vector to find similar vectors",
     },
+    {
+      name: "sparseVector",
+      type: "{ indices: number[], values: number[] }",
+      isOptional: true,
+      description: "Optional sparse vector for hybrid search. Must have matching indices and values arrays.",
+    },
     {
       name: "topK",
       type: "number",
@@ -115,6 +127,18 @@ Note: This method is a no-op for Upstash as indexes are created automatically.
       defaultValue: "false",
       description: "Whether to include vectors in the results",
     },
+    {
+      name: "fusionAlgorithm",
+      type: "FusionAlgorithm",
+      isOptional: true,
+      description: "Algorithm used to combine dense and sparse search results in hybrid search (e.g., RRF - Reciprocal Rank Fusion)",
+    },
+    {
+      name: "queryMode",
+      type: "QueryMode",
+      isOptional: true,
+      description: "Search mode: 'DENSE' for dense-only, 'SPARSE' for sparse-only, or 'HYBRID' for combined search",
+    },
   ]}
 />
 
@@ -173,18 +197,17 @@ interface IndexStats {
     {
       name: "update",
       type: "object",
-      description: "Update object containing vector and/or metadata",
+      description: "Update object containing vector, sparse vector, and/or metadata",
     },
   ]}
 />
 
 The `update` object can have the following properties:
 
-- `vector` (optional): An array of numbers representing the new vector.
+- `vector` (optional): An array of numbers representing the new dense vector.
+- `sparseVector` (optional): A sparse vector object with `indices` and `values` arrays for hybrid indexes.
 - `metadata` (optional): A record of key-value pairs for metadata.
 
-Throws an error if neither `vector` nor `metadata` is provided, or if only `metadata` is provided.
-
 ### deleteVector()
 
 <PropertiesTable
@@ -204,6 +227,90 @@ Throws an error if neither `vector` nor `metadata` is provided, or if only `meta
 
 Attempts to delete an item by its ID from the specified index. Logs an error message if the deletion fails.
 
+## Hybrid Vector Search
+
+Upstash Vector supports hybrid search that combines semantic search (dense vectors) with keyword-based search (sparse vectors) for improved relevance and accuracy.
+
+### Basic Hybrid Usage
+
+```typescript copy
+import { UpstashVector } from '@mastra/upstash';
+
+const vectorStore = new UpstashVector({
+  url: process.env.UPSTASH_VECTOR_URL,
+  token: process.env.UPSTASH_VECTOR_TOKEN
+});
+
+// Upsert vectors with both dense and sparse components
+const denseVectors = [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]];
+const sparseVectors = [
+  { indices: [1, 5, 10], values: [0.8, 0.6, 0.4] },
+  { indices: [2, 6, 11], values: [0.7, 0.5, 0.3] }
+];
+
+await vectorStore.upsert({
+  indexName: 'hybrid-index',
+  vectors: denseVectors,
+  sparseVectors: sparseVectors,
+  metadata: [{ title: 'Document 1' }, { title: 'Document 2' }]
+});
+
+// Query with hybrid search
+const results = await vectorStore.query({
+  indexName: 'hybrid-index',
+  queryVector: [0.1, 0.2, 0.3],
+  sparseVector: { indices: [1, 5], values: [0.9, 0.7] },
+  topK: 10
+});
+```
+
+### Advanced Hybrid Search Options
+
+```typescript copy
+import { FusionAlgorithm, QueryMode } from '@upstash/vector';
+
+// Query with specific fusion algorithm
+const fusionResults = await vectorStore.query({
+  indexName: 'hybrid-index',
+  queryVector: [0.1, 0.2, 0.3],
+  sparseVector: { indices: [1, 5], values: [0.9, 0.7] },
+  fusionAlgorithm: FusionAlgorithm.RRF,
+  topK: 10
+});
+
+// Dense-only search
+const denseResults = await vectorStore.query({
+  indexName: 'hybrid-index',
+  queryVector: [0.1, 0.2, 0.3],
+  queryMode: QueryMode.DENSE,
+  topK: 10
+});
+
+// Sparse-only search
+const sparseResults = await vectorStore.query({
+  indexName: 'hybrid-index',
+  queryVector: [0.1, 0.2, 0.3], // Still required for index structure
+  sparseVector: { indices: [1, 5], values: [0.9, 0.7] },
+  queryMode: QueryMode.SPARSE,
+  topK: 10
+});
+```
+
+### Updating Hybrid Vectors
+
+```typescript copy
+// Update both dense and sparse components
+await vectorStore.updateVector({
+  indexName: 'hybrid-index',
+  id: 'vector-id',
+  update: {
+    vector: [0.2, 0.3, 0.4],
+    sparseVector: { indices: [2, 7, 12], values: [0.9, 0.8, 0.6] },
+    metadata: { title: 'Updated Document' }
+  }
+});
+```
+
 ## Response Types
 
 Query results are returned in this format:

package/.docs/raw/reference/scorers/answer-relevancy.mdx

@@ -0,0 +1,114 @@
+---
+title: "Reference: Answer Relevancy | Scorers | Mastra Docs"
+description: Documentation for the Answer Relevancy Scorer in Mastra, which evaluates how well LLM outputs address the input query.
+---
+
+# Answer Relevancy Scorer
+
+The `createAnswerRelevancyScorer()` function accepts a single options object with the following properties:
+
+For usage example, see the [Answer Relevancy Examples](/examples/scorers/answer-relevancy).
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "model",
+      type: "LanguageModel",
+      required: true,
+      description: "Configuration for the model used to evaluate relevancy.",
+    },
+    {
+      name: "uncertaintyWeight",
+      type: "number",
+      required: false,
+      defaultValue: "0.3",
+      description: "Weight given to 'unsure' verdicts in scoring (0-1).",
+    },
+    {
+      name: "scale",
+      type: "number",
+      required: false,
+      defaultValue: "1",
+      description: "Maximum score value.",
+    },
+  ]}
+/>
+
+This function returns an instance of the MastraScorer class. The `.run()` method accepts the same input as other scorers (see the [MastraScorer reference](./mastra-scorer)), but the return value includes LLM-specific fields as documented below.
+
+## .run() Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "runId",
+      type: "string",
+      description: "The id of the run (optional).",
+    },
+    {
+      name: "score",
+      type: "number",
+      description: "Relevancy score (0 to scale, default 0-1)",
+    },
+    {
+      name: "extractPrompt",
+      type: "string",
+      description: "The prompt sent to the LLM for the extract step (optional).",
+    },
+    {
+      name: "extractStepResult",
+      type: "object",
+      description: "Object with extracted statements: { statements: string[] }",
+    },
+    {
+      name: "analyzePrompt",
+      type: "string",
+      description: "The prompt sent to the LLM for the analyze step (optional).",
+    },
+    {
+      name: "analyzeStepResult",
+      type: "object",
+      description: "Object with results: { results: Array<{ result: 'yes' | 'unsure' | 'no', reason: string }> }",
+    },
+    {
+      name: "reasonPrompt",
+      type: "string",
+      description: "The prompt sent to the LLM for the reason step (optional).",
+    },
+    {
+      name: "reason",
+      type: "string",
+      description: "Explanation of the score.",
+    },
+  ]}
+/>
+
+## Scoring Details
+
+The scorer evaluates relevancy through query-answer alignment, considering completeness and detail level, but not factual correctness.
+
+### Scoring Process
+
+1. **Statement Extraction:**
+   - Breaks output into meaningful statements while preserving context.
+2. **Relevance Analysis:**
+   - Each statement is evaluated as:
+     - "yes": Full weight for direct matches
+     - "unsure": Partial weight (default: 0.3) for approximate matches
+     - "no": Zero weight for irrelevant content
+3. **Score Calculation:**
+   - `((direct + uncertainty * partial) / total_statements) * scale`
+
+### Score Interpretation
+
+- 1.0: Perfect relevance - complete and accurate
+- 0.7-0.9: High relevance - minor gaps or imprecisions
+- 0.4-0.6: Moderate relevance - significant gaps
+- 0.1-0.3: Low relevance - major issues
+- 0.0: No relevance - incorrect or off-topic
+
+## Related
+
+- [Faithfulness Scorer](./faithfulness)