@mastra/mcp-docs-server 0.13.10 → 0.13.11-alpha.0

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

@@ -0,0 +1,62 @@
+---
+title: "Reference: getDefaultStreamOptions() | Agents | Mastra Docs"
+description: "Documentation for the `.getDefaultStreamOptions()` method in Mastra agents, which retrieves the default options used for stream calls."
+---
+
+# getDefaultStreamOptions()
+
+The `.getDefaultStreamOptions()` method retrieves the default streaming options configured for an agent, resolving them if they're a function. These options are used as the base configuration for all `stream()` calls unless overridden.
+
+## Usage example
+
+```typescript showLineNumbers copy
+const defaultOptions = await agent.getDefaultStreamOptions();
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "options",
+      type: "{ runtimeContext?: RuntimeContext }",
+      isOptional: true,
+      defaultValue: "{}",
+      description: "Optional configuration object containing runtime context.",
+    },
+  ]}
+/>
+
+## Extended usage example
+
+```typescript showLineNumbers copy
+const defaultOptions = await agent.getDefaultStreamOptions({
+  runtimeContext: new RuntimeContext()
+});
+```
+
+### Options parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      isOptional: true,
+      defaultValue: "new RuntimeContext()",
+      description: "Runtime context for dependency injection and contextual information.",
+    },
+  ]}
+/>
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "defaultOptions",
+      type: "AgentStreamOptions | Promise<AgentStreamOptions>",
+      description: "The default streaming options configured for the agent, either as a direct object or a promise that resolves to the options.",
+    },
+  ]}
+/>

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

@@ -0,0 +1,62 @@
+---
+title: "Reference: getDefaultVNextStreamOptions() | Agents | Mastra Docs"
+description: "Documentation for the `.getDefaultVNextStreamOptions()` method in Mastra agents, which retrieves the default options used for streamVNext calls."
+---
+
+# getDefaultVNextStreamOptions()
+
+The `.getDefaultVNextStreamOptions()` method retrieves the default vNext streaming options configured for an agent, resolving them if they're a function. These options are used as the base configuration for all `streamVNext()` calls unless overridden.
+
+## Usage example
+
+```typescript showLineNumbers copy
+const defaultOptions = await agent.getDefaultVNextStreamOptions();
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "options",
+      type: "{ runtimeContext?: RuntimeContext }",
+      isOptional: true,
+      defaultValue: "{}",
+      description: "Optional configuration object containing runtime context.",
+    },
+  ]}
+/>
+
+## Extended usage example
+
+```typescript showLineNumbers copy
+const defaultOptions = await agent.getDefaultVNextStreamOptions({
+  runtimeContext: new RuntimeContext()
+});
+```
+
+### Options parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      isOptional: true,
+      defaultValue: "new RuntimeContext()",
+      description: "Runtime context for dependency injection and contextual information.",
+    },
+  ]}
+/>
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "defaultOptions",
+      type: "AgentVNextStreamOptions<Output, StructuredOutput> | Promise<AgentVNextStreamOptions<Output, StructuredOutput>>",
+      description: "The default vNext streaming options configured for the agent, either as a direct object or a promise that resolves to the options.",
+    },
+  ]}
+/>

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

@@ -0,0 +1,30 @@
+---
+title: "Reference: getDescription() | Agents | Mastra Docs"
+description: "Documentation for the `.getDescription()` method in Mastra agents, which retrieves the agent's description."
+---
+
+# getDescription()
+
+The `.getDescription()` method retrieves the description configured for an agent. This method returns a simple string description that describes the agent's purpose and capabilities.
+
+## Usage example
+
+```typescript showLineNumbers copy
+const description = agent.getDescription();
+```
+
+## Parameters
+
+This method takes no parameters.
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "description",
+      type: "string",
+      description: "The description of the agent, or an empty string if no description was configured.",
+    },
+  ]}
+/>

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

@@ -1,99 +1,62 @@
 ---
-title: "Reference: Agent.getInstructions() | Agents | Mastra Docs"
+title: "Reference: getInstructions() | Agents | Mastra Docs"
 description: "Documentation for the `.getInstructions()` method in Mastra agents, which retrieves the instructions that guide the agent's behavior."
 ---
 
-# Agent.getInstructions()
+# getInstructions()
 
-The `getInstructions()` method retrieves the instructions configured for an agent, resolving them if they're a function. These instructions guide the agent's behavior and define its capabilities and constraints.
+The `.getInstructions()` method retrieves the instructions configured for an agent, resolving them if they're a function. These instructions guide the agent's behavior and define its capabilities and constraints.
 
-## Syntax
+## Usage example
 
-```typescript
-getInstructions({ runtimeContext }: { runtimeContext?: RuntimeContext } = {}): string | Promise<string>
+```typescript showLineNumbers copy
+const instructions = await agent.getInstructions();
 ```
 
 ## Parameters
 
-<br />
 <PropertiesTable
   content={[
     {
-      name: "runtimeContext",
-      type: "RuntimeContext",
+      name: "options",
+      type: "{ runtimeContext?: RuntimeContext }",
       isOptional: true,
-      description:
-        "Runtime context for dependency injection and contextual information.",
+      defaultValue: "{}",
+      description: "Optional configuration object containing runtime context.",
     },
   ]}
 />
 
-## Return Value
-
-Returns a string or a Promise that resolves to a string containing the agent's instructions.
-
-## Description
-
-The `getInstructions()` method is used to access the instructions that guide an agent's behavior. It resolves the instructions, which can be either directly provided as a string or returned from a function.
-
-Instructions are a critical component of an agent's configuration as they define:
-
-- The agent's role and personality
-- Task-specific guidance
-- Constraints on the agent's behavior
-- Context for handling user requests
-
-## Examples
+## Extended usage example
 
-### Basic Usage
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
-
-// Create an agent with static instructions
-const agent = new Agent({
-  name: "assistant",
-  instructions:
-    "You are a helpful assistant that provides concise and accurate information.",
-  model: openai("gpt-4o"),
+```typescript showLineNumbers copy
+const instructions = await agent.getInstructions({
+  runtimeContext: new RuntimeContext()
 });
-
-// Get the instructions
-const instructions = await agent.getInstructions();
-console.log(instructions); // "You are a helpful assistant that provides concise and accurate information."
 ```
 
-### Using with RuntimeContext
+### Options parameters
 
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { RuntimeContext } from "@mastra/core/runtime-context";
-import { openai } from "@ai-sdk/openai";
-
-// Create an agent with dynamic instructions
-const agent = new Agent({
-  name: "contextual-assistant",
-  instructions: ({ runtimeContext }) => {
-    // Dynamic instructions based on runtime context
-    const userPreference = runtimeContext.get("userPreference");
-    const expertise = runtimeContext.get("expertise") || "general";
-
-    if (userPreference === "technical") {
-      return `You are a technical assistant specializing in ${expertise}. Provide detailed technical explanations.`;
-    }
-
-    return `You are a helpful assistant providing easy-to-understand information about ${expertise}.`;
-  },
-  model: openai("gpt-4o"),
-});
+<PropertiesTable
+  content={[
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      isOptional: true,
+      defaultValue: "undefined",
+      description: "Runtime context for dependency injection and contextual information.",
+    },
+  ]}
+/>
 
-// Create a runtime context with user preferences
-const context = new RuntimeContext();
-context.set("userPreference", "technical");
-context.set("expertise", "machine learning");
+## Returns
 
-// Get the instructions using the runtime context
-const instructions = await agent.getInstructions({ runtimeContext: context });
-console.log(instructions); // "You are a technical assistant specializing in machine learning. Provide detailed technical explanations."
-```
+<PropertiesTable
+  content={[
+    {
+      name: "instructions",
+      type: "string | Promise<string>",
+      description: "The instructions configured for the agent, either as a direct string or a promise that resolves to the instructions.",
+    },
+  ]}
+/>

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

@@ -0,0 +1,69 @@
+---
+title: "Reference: getLLM() | Agents | Mastra Docs"
+description: "Documentation for the `.getLLM()` method in Mastra agents, which retrieves the language model instance."
+---
+
+# getLLM()
+
+The `.getLLM()` method retrieves the language model instance configured for an agent, resolving it if it's a function. This method provides access to the underlying LLM that powers the agent's capabilities.
+
+## Usage example
+
+```typescript showLineNumbers copy
+const llm = await agent.getLLM();
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "options",
+      type: "{ runtimeContext?: RuntimeContext; model?: MastraLanguageModel | DynamicArgument<MastraLanguageModel> }",
+      isOptional: true,
+      defaultValue: "{}",
+      description: "Optional configuration object containing runtime context and optional model override.",
+    },
+  ]}
+/>
+
+## Extended usage example
+
+```typescript showLineNumbers copy
+const llm = await agent.getLLM({
+  runtimeContext: new RuntimeContext(),
+  model: openai('gpt-4')
+});
+```
+
+### Options parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      isOptional: true,
+      defaultValue: "new RuntimeContext()",
+      description: "Runtime context for dependency injection and contextual information.",
+    },
+    {
+      name: "model",
+      type: "MastraLanguageModel | DynamicArgument<MastraLanguageModel>",
+      isOptional: true,
+      description: "Optional model override. If provided, this model will be used instead of the agent's configured model.",
+    },
+  ]}
+/>
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "llm",
+      type: "MastraLLMBase | Promise<MastraLLMBase>",
+      description: "The language model instance configured for the agent, either as a direct instance or a promise that resolves to the LLM.",
+    },
+  ]}
+/>

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

@@ -1,139 +1,62 @@
 ---
-title: "Reference: Agent.getMemory() | Agents | Mastra Docs"
+title: "Reference: getMemory() | Agents | Mastra Docs"
 description: "Documentation for the `.getMemory()` method in Mastra agents, which retrieves the memory system associated with the agent."
 ---
 
-# Agent.getMemory()
+# getMemory()
 
-The `getMemory()` method retrieves the memory system associated with an agent. This method is used to access the agent's memory capabilities for storing and retrieving information across conversations.
+The `.getMemory()` method retrieves the memory system associated with an agent. This method is used to access the agent's memory capabilities for storing and retrieving information across conversations.
 
-## Syntax
+## Usage example
 
-```typescript
-getMemory(): MastraMemory | undefined
+```typescript showLineNumbers copy
+const memory = await agent.getMemory();
 ```
 
 ## Parameters
 
-This method does not take any parameters.
-
-## Return Value
-
-Returns a `MastraMemory` instance if a memory system is configured for the agent, or `undefined` if no memory system is configured.
-
-## Description
-
-The `getMemory()` method is used to access the memory system associated with an agent. Memory systems allow agents to:
-
-- Store and retrieve information across multiple interactions
-- Maintain conversation history
-- Remember user preferences and context
-- Provide personalized responses based on past interactions
-
-This method is often used in conjunction with `hasOwnMemory()` to check if an agent has a memory system before attempting to use it.
-
-## Examples
-
-### Basic Usage
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { Memory } from "@mastra/memory";
-import { openai } from "@ai-sdk/openai";
-
-// Create a memory system
-const memory = new Memory();
-
-// Create an agent with memory
-const agent = new Agent({
-  name: "memory-assistant",
-  instructions:
-    "You are a helpful assistant that remembers previous conversations.",
-  model: openai("gpt-4o"),
-  memory,
-});
-
-// Get the memory system
-const agentMemory = agent.getMemory();
-
-if (agentMemory) {
-  // Use the memory system to retrieve thread messages
-  const thread = await agentMemory.getThreadById({
-    resourceId: "user-123",
-    threadId: "conversation-1",
-  });
-
-  console.log("Retrieved thread:", thread);
-}
-```
-
-### Checking for Memory Before Using
+<PropertiesTable
+  content={[
+    {
+      name: "options",
+      type: "{ runtimeContext?: RuntimeContext }",
+      isOptional: true,
+      defaultValue: "{}",
+      description: "Optional configuration object containing runtime context.",
+    },
+  ]}
+/>
 
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
+## Extended usage example
 
-// Create an agent without memory
-const agent = new Agent({
-  name: "stateless-assistant",
-  instructions: "You are a helpful assistant.",
-  model: openai("gpt-4o"),
+```typescript showLineNumbers copy
+const memory = await agent.getMemory({
+  runtimeContext: new RuntimeContext()
 });
-
-// Check if the agent has memory before using it
-if (agent.hasOwnMemory()) {
-  const memory = agent.getMemory();
-  // Use memory...
-} else {
-  console.log("This agent does not have a memory system.");
-}
 ```
 
-### Using Memory in a Conversation
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { Memory } from "@mastra/memory";
-import { openai } from "@ai-sdk/openai";
-
-// Create a memory system
-const memory = new Memory();
-
-// Create an agent with memory
-const agent = new Agent({
-  name: "memory-assistant",
-  instructions:
-    "You are a helpful assistant that remembers previous conversations.",
-  model: openai("gpt-4o"),
-  memory,
-});
-
-// First interaction - store information
-await agent.generate("My name is Alice.", {
-  resourceId: "user-123",
-  threadId: "conversation-1",
-});
+### Options parameters
 
-// Later interaction - retrieve information
-const result = await agent.generate("What's my name?", {
-  resourceId: "user-123",
-  threadId: "conversation-1",
-});
+<PropertiesTable
+  content={[
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      isOptional: true,
+      defaultValue: "new RuntimeContext()",
+      description: "Runtime context for dependency injection and contextual information.",
+    },
+  ]}
+/>
 
-console.log(result.text); // Should mention "Alice"
+## Returns
 
-// Access the memory system directly
-const agentMemory = agent.getMemory();
-if (agentMemory) {
-  // Retrieve messages from the thread
-  const { messages } = await agentMemory.query({
-    resourceId: "user-123",
-    threadId: "conversation-1",
-    selectBy: {
-      last: 10, // Get the last 10 messages
+<PropertiesTable
+  content={[
+    {
+      name: "memory",
+      type: "Promise<MastraMemory | undefined>",
+      description: "A promise that resolves to the memory system configured for the agent, or undefined if no memory system is configured.",
     },
-  });
-
-  console.log("Retrieved messages:", messages);
-}
-```
+  ]}
+/>

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

@@ -1,101 +1,62 @@
 ---
-title: "Reference: Agent.getModel() | Agents | Mastra Docs"
+title: "Reference: getModel() | Agents | Mastra Docs"
 description: "Documentation for the `.getModel()` method in Mastra agents, which retrieves the language model that powers the agent."
 ---
 
-# Agent.getModel()
+# getModel()
 
-The `getModel()` method retrieves the language model configured for an agent, resolving it if it's a function. This method is used to access the underlying model that powers the agent's capabilities.
+The `.getModel()` method retrieves the language model configured for an agent, resolving it if it's a function. This method is used to access the underlying model that powers the agent's capabilities.
 
-## Syntax
+## Usage example
 
-```typescript
-getModel({ runtimeContext = new RuntimeContext() }: { runtimeContext?: RuntimeContext } = {}): MastraLanguageModel | Promise<MastraLanguageModel>
+```typescript showLineNumbers copy
+const model = await agent.getModel();
 ```
 
 ## Parameters
 
-<br />
 <PropertiesTable
   content={[
     {
-      name: "runtimeContext",
-      type: "RuntimeContext",
+      name: "{ runtimeContext = new RuntimeContext() }",
+      type: "{ runtimeContext?: RuntimeContext }",
       isOptional: true,
-      description:
-        "Runtime context for dependency injection and contextual information.",
+      defaultValue: "new RuntimeContext()",
+      description: "Optional configuration object containing runtime context.",
     },
   ]}
 />
 
-## Return Value
-
-Returns a `MastraLanguageModel` instance or a Promise that resolves to a `MastraLanguageModel` instance.
-
-## Description
-
-The `getModel()` method is used to access the language model that powers an agent. It resolves the model, which can be either directly provided or returned from a function.
-
-The language model is a crucial component of an agent as it determines:
-
-- The quality and capabilities of the agent's responses
-- The available features (like function calling, structured output, etc.)
-- The cost and performance characteristics of the agent
-
-## Examples
+## Extended usage example
 
-### Basic Usage
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { openai } from "@ai-sdk/openai";
-
-// Create an agent with a static model
-const agent = new Agent({
-  name: "assistant",
-  instructions: "You are a helpful assistant.",
-  model: openai("gpt-4o"),
+```typescript showLineNumbers copy
+const model = await agent.getModel({
+  runtimeContext: new RuntimeContext()
 });
-
-// Get the model
-const model = await agent.getModel();
-console.log(model.id); // "gpt-4o"
 ```
 
-### Using with RuntimeContext
+### Options parameters
 
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { RuntimeContext } from "@mastra/core/runtime-context";
-import { openai } from "@ai-sdk/openai";
-import { anthropic } from "@ai-sdk/anthropic";
-
-// Create an agent with dynamic model selection
-const agent = new Agent({
-  name: "dynamic-model-assistant",
-  instructions: "You are a helpful assistant.",
-  model: ({ runtimeContext }) => {
-    // Dynamic model selection based on runtime context
-    const preferredProvider = runtimeContext.get("preferredProvider");
-    const highQuality = runtimeContext.get("highQuality") === true;
-
-    if (preferredProvider === "anthropic") {
-      return highQuality
-        ? anthropic("claude-3-opus")
-        : anthropic("claude-3-sonnet");
-    }
-
-    // Default to OpenAI
-    return highQuality ? openai("gpt-4o") : openai("gpt-4.1-nano");
-  },
-});
+<PropertiesTable
+  content={[
+    {
+      name: "runtimeContext",
+      type: "RuntimeContext",
+      isOptional: true,
+      defaultValue: "undefined",
+      description: "Runtime context for dependency injection and contextual information.",
+    },
+  ]}
+/>
 
-// Create a runtime context with preferences
-const context = new RuntimeContext();
-context.set("preferredProvider", "anthropic");
-context.set("highQuality", true);
+## Returns
 
-// Get the model using the runtime context
-const model = await agent.getModel({ runtimeContext: context });
-console.log(model.id); // "claude-3-opus"
-```
+<PropertiesTable
+  content={[
+    {
+      name: "model",
+      type: "MastraLanguageModel | Promise<MastraLanguageModel>",
+      description: "The language model configured for the agent, either as a direct instance or a promise that resolves to the model.",
+    },
+  ]}
+/>