@mastra/mcp-docs-server 0.13.21 → 0.13.22-alpha.0

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

@@ -1,95 +1,60 @@
 ---
-section: Memory
-title: deleteMessages
-slug: reference/memory/deleteMessages
-categorySlug: reference
-layout: guide
+title: "Reference: Memory.deleteMessages() | Memory | Mastra Docs"
+description: "Documentation for the `Memory.deleteMessages()` method in Mastra, which deletes multiple messages by their IDs."
 ---
 
-# `deleteMessages`
+# Memory.deleteMessages()
 
-Deletes one or more messages from the memory storage. This method accepts arrays to delete multiple messages in a single operation.
+The `.deleteMessages()` method deletes multiple messages by their IDs.
 
-## Syntax
+## Usage Example
 
-```typescript
-memory.deleteMessages(input: MessageDeleteInput): Promise<void>
-
-type MessageDeleteInput = 
-  | string[]                  // Array of message IDs
-  | { id: string }[]         // Array of message objects
+```typescript copy
+await memory?.deleteMessages(["671ae63f-3a91-4082-a907-fe7de78e10ec"]);
 ```
 
 ## 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
+<PropertiesTable
+  content={[
+    {
+      name: "messageIds",
+      type: "string[]",
+      description: "Array of message IDs to delete",
+      isOptional: false,
+    },
+  ]}
+/>
 
 ## Returns
 
-A Promise that resolves when all messages have been successfully deleted.
-
-## Examples
+<PropertiesTable
+  content={[
+    {
+      name: "void",
+      type: "Promise<void>",
+      description: "A promise that resolves when all messages are deleted",
+    },
+  ]}
+/>
 
-### Delete a single message
+## Extended usage example
 
-```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' }]);
-```
+```typescript filename="src/test-memory.ts" showLineNumbers copy
+import { mastra } from "./mastra";
+import { UIMessageWithMetadata } from "@mastra/core/agent";
 
-### 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);
-```
+const agent = mastra.getAgent("agent");
+const memory = await agent.getMemory();
 
-### Error handling
+const { uiMessages } = await memory!.query({ threadId: "thread-123" });
 
-```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);
-}
+const messageIds = uiMessages.map((message: UIMessageWithMetadata) => message.id);
+await memory?.deleteMessages([...messageIds]);
 ```
 
-## Notes
+## Related
 
-- 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
+- [Memory Class Reference](/reference/memory/Memory.mdx)
+- [query](/reference/memory/query.mdx)
+- [Getting Started with Memory](/docs/memory/overview.mdx)

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

@@ -1,15 +1,16 @@
-# getThreadById Reference
+---
+title: "Reference: Memory.getThreadById() | Memory | Mastra Docs"
+description: "Documentation for the `Memory.getThreadById()` method in Mastra, which retrieves a specific thread by its ID."
+---
 
-The `getThreadById` function retrieves a specific thread by its ID from storage.
+# Memory.getThreadById()
+
+The `.getThreadById()` method retrieves a specific thread by its ID.
 
 ## Usage Example
 
 ```typescript
-import { Memory } from "@mastra/core/memory";
-
-const memory = new Memory(config);
-
-const thread = await memory.getThreadById({ threadId: "thread-123" });
+await memory?.getThreadById({ threadId: "thread-123" });
 ```
 
 ## Parameters
@@ -30,10 +31,9 @@ const thread = await memory.getThreadById({ threadId: "thread-123" });
 <PropertiesTable
   content={[
     {
-      name: "StorageThreadType | null",
-      type: "Promise",
-      description:
-        "A promise that resolves to the thread associated with the given ID, or null if not found.",
+      name: "thread",
+      type: "Promise<StorageThreadType | null>",
+      description: "A promise that resolves to the thread associated with the given ID, or null if not found.",
     },
   ]}
 />

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

@@ -1,25 +1,16 @@
-# getThreadsByResourceId Reference
+---
+title: "Reference: Memory.getThreadsByResourceId() | Memory | Mastra Docs"
+description: "Documentation for the `Memory.getThreadsByResourceId()` method in Mastra, which retrieves all threads that belong to a specific resource."
+---
 
-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.
+# Memory.getThreadsByResourceId()
+
+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
 
 ```typescript
-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",
-});
+await memory?.getThreadsByResourceId({ resourceId: "user-123" });
 ```
 
 ## Parameters
@@ -40,24 +31,13 @@ const threadsByUpdate = await memory.getThreadsByResourceId({
     },
     {
       name: "sortDirection",
-      type: "ThreadSortDirection", 
+      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
 
@@ -72,6 +52,23 @@ interface ThreadSortOptions {
   ]}
 />
 
+## Extended usage example
+
+```typescript filename="src/test-memory.ts" showLineNumbers copy
+import { mastra } from "./mastra";
+
+const agent = mastra.getAgent("agent");
+const memory = await agent.getMemory();
+
+const thread = await memory?.getThreadsByResourceId({
+  resourceId: "user-123",
+  orderBy: "updatedAt",
+  sortDirection: "ASC"
+});
+
+console.log(thread);
+```
+
 ### Related
 
 - [Memory Class Reference](/reference/memory/Memory.mdx)

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

@@ -1,55 +1,20 @@
-# getThreadsByResourceIdPaginated Reference
+---
+title: "Reference: Memory.getThreadsByResourceIdPaginated() | Memory | Mastra Docs"
+description: "Documentation for the `Memory.getThreadsByResourceIdPaginated()` method in Mastra, which retrieves threads associated with a specific resource ID with pagination support."
+---
 
-The `getThreadsByResourceIdPaginated` function retrieves threads associated with a specific resource ID with pagination support. This method addresses performance and memory usage concerns when dealing with large numbers of threads by returning results in manageable chunks with metadata for navigation.
+# Memory.getThreadsByResourceIdPaginated()
 
-## Usage Example
-
-```typescript
-import { Memory } from "@mastra/core/memory";
+The `.getThreadsByResourceIdPaginated()` method retrieves threads associated with a specific resource ID with pagination support.
 
-const memory = new Memory(config);
+## Usage Example
 
-// Basic usage with default parameters
-const result = await memory.getThreadsByResourceIdPaginated({
-  resourceId: "resource-123",
+```typescript copy
+await memory.getThreadsByResourceIdPaginated({
+  resourceId: "user-123",
   page: 0,
-  perPage: 100,
+  perPage: 10
 });
-
-console.log(result.threads);
-console.log(result.total);
-console.log(result.hasMore);
-
-// Custom pagination with sorting
-const customResult = await memory.getThreadsByResourceIdPaginated({
-  resourceId: "resource-123",
-  page: 2,
-  perPage: 50,
-  orderBy: "updatedAt",
-  sortDirection: "ASC",
-});
-
-// Process paginated results
-let currentPage = 0;
-let hasMorePages = true;
-
-while (hasMorePages) {
-  const pageResult = await memory.getThreadsByResourceIdPaginated({
-    resourceId: "user-456",
-    page: currentPage,
-    perPage: 25,
-    orderBy: "createdAt",
-    sortDirection: "DESC",
-  });
-  
-  // Process threads
-  pageResult.threads.forEach(thread => {
-    console.log(`Thread: ${thread.id}, Created: ${thread.createdAt}`);
-  });
-  
-  hasMorePages = pageResult.hasMore;
-  currentPage++;
-}
 ```
 
 ## Parameters
@@ -59,126 +24,83 @@ while (hasMorePages) {
     {
       name: "resourceId",
       type: "string",
-      description: "The ID of the resource whose threads are to be retrieved.",
+      description: "The ID of the resource whose threads are to be retrieved",
       isOptional: false,
     },
     {
       name: "page",
       type: "number",
-      description: "Page number to retrieve. Must be a positive integer.",
+      description: "Page number to retrieve",
       isOptional: false,
     },
     {
       name: "perPage",
       type: "number",
-      description: "Number of threads to return per page. Must be a positive integer.",
+      description: "Number of threads to return per page",
       isOptional: false,
     },
     {
       name: "orderBy",
-      type: "ThreadOrderBy",
-      description: "Field to sort threads by. Accepts 'createdAt' or 'updatedAt'. Default: 'createdAt'",
+      type: "'createdAt' | 'updatedAt'",
+      description: "Field to sort threads by",
       isOptional: true,
     },
     {
       name: "sortDirection",
-      type: "ThreadSortDirection", 
-      description: "Sort order direction. Accepts 'ASC' or 'DESC'. Default: 'DESC'",
+      type: "'ASC' | 'DESC'",
+      description: "Sort order direction",
       isOptional: true,
     },
   ]}
 />
 
-## Type Definitions
-
-```typescript
-type ThreadOrderBy = 'createdAt' | 'updatedAt';
-type ThreadSortDirection = 'ASC' | 'DESC';
-
-interface ThreadSortOptions {
-  orderBy?: ThreadOrderBy;
-  sortDirection?: ThreadSortDirection;
-}
-
-interface PaginationInfo {
-  total: number;      // Total number of threads across all pages
-  page: number;       // Current page number
-  perPage: number;    // Number of threads per page
-  hasMore: boolean;   // Whether additional pages exist
-}
-```
-
 ## Returns
 
 <PropertiesTable
   content={[
     {
-      name: "threads",
-      type: "StorageThreadType[]",
-      description: "Array of threads for the current page, sorted according to the specified criteria.",
-    },
-    {
-      name: "total",
-      type: "number",
-      description: "Total number of threads associated with the resource ID across all pages.",
-    },
-    {
-      name: "page",
-      type: "number",
-      description: "Current page number.",
-    },
-    {
-      name: "perPage",
-      type: "number",
-      description: "Number of threads returned per page as specified in the request.",
-    },
-    {
-      name: "hasMore",
-      type: "boolean",
-      description: "Indicates whether additional pages of results are available.",
+      name: "result",
+      type: "Promise<PaginationInfo & { threads: StorageThreadType[] }>",
+      description: "A promise that resolves to paginated thread results with metadata",
     },
   ]}
 />
 
-## Technical Notes
-
-### Performance Considerations
-
-This method executes database-level pagination using LIMIT/OFFSET operations (or equivalent), which provides better performance and memory usage compared to retrieving all threads and paginating in application code.
-
-### Default Values
+## Extended usage example
 
-- `orderBy`: Defaults to `"createdAt"`
-- `sortDirection`: Defaults to `"DESC"` (newest first)
+```typescript filename="src/test-memory.ts" showLineNumbers copy
+import { mastra } from "./mastra";
 
-### Relationship to getThreadsByResourceId
+const agent = mastra.getAgent("agent");
+const memory = await agent.getMemory();
 
-The paginated version (`getThreadsByResourceIdPaginated`) complements the existing `getThreadsByResourceId` method:
-
-- Use `getThreadsByResourceId` when you need all threads for a resource
-- Use `getThreadsByResourceIdPaginated` when working with potentially large thread collections or implementing UI pagination
+let currentPage = 0;
+let hasMorePages = true;
 
-Both methods support the same sorting options for consistency.
+while (hasMorePages) {
+  const threads = await memory?.getThreadsByResourceIdPaginated({
+    resourceId: "user-123",
+    page: currentPage,
+    perPage: 25,
+    orderBy: "createdAt",
+    sortDirection: "ASC"
+  });
 
-### Error Handling
+  if (!threads) {
+    console.log("No threads");
+    break;
+  }
 
-```typescript
-try {
-  const result = await memory.getThreadsByResourceIdPaginated({
-    resourceId: "resource-123",
-    page: 0,
-    perPage: 100,
+  threads.threads.forEach((thread) => {
+    console.log(`Thread: ${thread.id}, Created: ${thread.createdAt}`);
   });
-  
-  if (result.threads.length === 0) {
-    console.log("No threads found for this resource");
-  }
-} catch (error) {
-  console.error("Failed to retrieve paginated threads:", error);
+
+  hasMorePages = threads.hasMore;
+  currentPage++;
 }
 ```
 
-### Related
+## Related
 
 - [Memory Class Reference](/reference/memory/Memory.mdx)
 - [getThreadsByResourceId](/reference/memory/getThreadsByResourceId.mdx) - Non-paginated version