@mastra/mcp-docs-server 0.13.18 → 0.13.19-alpha.1

package/.docs/raw/reference/core/getVectors.mdx

@@ -0,0 +1,35 @@
+---
+title: "Reference: Mastra.getVectors() | Core | Mastra Docs"
+description: "Documentation for the `Mastra.getVectors()` method in Mastra, which retrieves all configured vector stores."
+---
+
+# Mastra.getVectors()
+
+The `.getVectors()` method is used to retrieve all vector stores that have been configured in the Mastra instance.
+
+## Usage example
+
+```typescript copy
+mastra.getVectors();
+```
+
+## Parameters
+
+This method does not accept any parameters.
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "vectors",
+      type: "TVectors",
+      description: "A record of all configured vector stores, where keys are vector store names and values are vector store instances.",
+    },
+  ]}
+/>
+
+## Related
+
+- [Vector stores overview](../../docs/rag/vector-databases.mdx)
+- [RAG overview](../../docs/rag/overview.mdx)

package/.docs/raw/reference/core/getWorkflow.mdx

@@ -0,0 +1,49 @@
+---
+title: "Reference: Mastra.getWorkflow() | Core | Mastra Docs"
+description: "Documentation for the `Mastra.getWorkflow()` method in Mastra, which retrieves a workflow by ID."
+---
+
+# Mastra.getWorkflow()
+
+The `.getWorkflow()` method is used to retrieve a workflow by its ID. The method accepts a workflow ID and an optional options object.
+
+## Usage example
+
+```typescript copy
+mastra.getWorkflow("testWorkflow");
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "id",
+      type: "TWorkflowId extends keyof TWorkflows",
+      description: "The ID of the workflow to retrieve. Must be a valid workflow ID that exists in the Mastra configuration.",
+    },
+    {
+      name: "options",
+      type: "{ serialized?: boolean }",
+      description: "Optional configuration object. When `serialized` is true, returns only the workflow name instead of the full workflow instance.",
+      optional: true,
+    },
+  ]}
+/>
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "workflow",
+      type: "TWorkflows[TWorkflowId]",
+      description: "The workflow instance with the specified ID. Throws an error if the workflow is not found.",
+    },
+  ]}
+/>
+
+## Related
+
+- [Workflows overview](../../docs/workflows/overview.mdx)
+- [Dynamic workflows](../../docs/workflows/dynamic-workflows.mdx)

package/.docs/raw/reference/core/getWorkflows.mdx

@@ -0,0 +1,44 @@
+---
+title: "Reference: Mastra.getWorkflows() | Core | Mastra Docs"
+description: "Documentation for the `Mastra.getWorkflows()` method in Mastra, which retrieves all configured workflows."
+---
+
+# Mastra.getWorkflows()
+
+The `.getWorkflows()` method is used to retrieve all workflows that have been configured in the Mastra instance. The method accepts an optional options object.
+
+## Usage example
+
+```typescript copy
+mastra.getWorkflows();
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "options",
+      type: "{ serialized?: boolean }",
+      description: "Optional configuration object. When `serialized` is true, returns simplified workflow objects with only the name property instead of full workflow instances.",
+      optional: true,
+    },
+  ]}
+/>
+
+## Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "workflows",
+      type: "Record<string, Workflow>",
+      description: "A record of all configured workflows, where keys are workflow IDs and values are workflow instances (or simplified objects if serialized is true).",
+    },
+  ]}
+/>
+
+## Related
+
+- [Workflows overview](../../docs/workflows/overview.mdx)
+- [Dynamic workflows](../../docs/workflows/dynamic-workflows.mdx)

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

@@ -3,7 +3,7 @@ title: "Mastra Core"
 description: Documentation for the Mastra Class, the core entry point for managing agents, workflows, MCP servers, and server endpoints.
 ---
 
-# The Mastra Class
+# Mastra Class
 
 The `Mastra` class is the central orchestrator in any Mastra application, managing agents, workflows, storage, logging, telemetry, and more. Typically, you create a single instance of `Mastra` to coordinate your application.
 
@@ -13,42 +13,29 @@ Think of `Mastra` as a top-level registry:
 - **tools** aren’t registered on `Mastra` directly but are associated with agents and discovered automatically.
 
 
-## Importing
+## Usage example
 
-```typescript
-import { Mastra } from "@mastra/core/mastra";
-```
-
-## Constructor
-
-Creates a new `Mastra` instance with the specified configuration.
-
-```typescript
-constructor(config?: Config);
-```
-
-## Initialization
-
-The Mastra class is typically initialized in your `src/mastra/index.ts` file:
-
-```typescript filename="src/mastra/index.ts" showLineNumbers copy
-import { Mastra } from "@mastra/core/mastra";
-import { LibSQLStore } from "@mastra/libsql";
-import { weatherAgent } from "./agents/weather-agent";
+```typescript filename="src/mastra/index.ts"
+import { Mastra } from '@mastra/core/mastra';
+import { PinoLogger } from '@mastra/loggers';
+import { LibSQLStore } from '@mastra/libsql';
+import { weatherWorkflow } from './workflows/weather-workflow';
+import { weatherAgent } from './agents/weather-agent';
 
 export const mastra = new Mastra({
+  workflows: { weatherWorkflow },
   agents: { weatherAgent },
   storage: new LibSQLStore({
     url: ":memory:",
   }),
+  logger: new PinoLogger({
+    name: 'Mastra',
+    level: 'info',
+  }),
 });
 ```
 
-## Configuration Object
-
-The constructor accepts an optional `Config` object to customize its behavior and integrate various Mastra components. All properties on the `Config` object are optional.
-
-### Properties
+## Constructor parameters
 
 <PropertiesTable
   content={[
@@ -145,156 +132,5 @@ The constructor accepts an optional `Config` object to customize its behavior an
   ]}
 />
 
-## Usage
-
-Any of the below methods can be used with the Mastra class, for example:
-
-```typescript {3} filename="example.ts" showLineNumbers
-import { mastra } from "./mastra";
-
-const agent = mastra.getAgent("weatherAgent");
-const result = await agent.generate("What's the weather like in London?");
-```
-
-### Methods
-
-<PropertiesTable
-  content={[
-    {
-      name: "getAgent(name)",
-      type: "Agent",
-      description:
-        "Returns an agent instance by id. Throws if agent not found.",
-      example: 'const agent = mastra.getAgent("agentOne");',
-    },
-    {
-      name: "getAgents()",
-      type: "Record<string, Agent>",
-      description: "Returns all registered agents as a key-value object.",
-      example: "const agents = mastra.getAgents();",
-    },
-    {
-      name: "getWorkflow(id, { serialized })",
-      type: "Workflow",
-      description:
-        "Returns a workflow instance by id. The serialized option (default: false) returns a simplified representation with just the name.",
-      example: 'const workflow = mastra.getWorkflow("myWorkflow");',
-    },
-    {
-      name: "getWorkflows({ serialized })",
-      type: "Record<string, Workflow>",
-      description:
-        "Returns all registered workflows. The serialized option (default: false) returns simplified representations.",
-      example: "const workflows = mastra.getWorkflows();",
-    },
-    {
-      name: "getVector(name)",
-      type: "MastraVector",
-      description:
-        "Returns a vector store instance by name. Throws if not found.",
-      example: 'const vectorStore = mastra.getVector("myVectorStore");',
-    },
-    {
-      name: "getVectors()",
-      type: "Record<string, MastraVector>",
-      description:
-        "Returns all registered vector stores as a key-value object.",
-      example: "const vectorStores = mastra.getVectors();",
-    },
-    {
-      name: "getDeployer()",
-      type: "MastraDeployer | undefined",
-      description: "Returns the configured deployer instance, if any.",
-      example: "const deployer = mastra.getDeployer();",
-    },
-    {
-      name: "getStorage()",
-      type: "MastraStorage | undefined",
-      description: "Returns the configured storage instance.",
-      example: "const storage = mastra.getStorage();",
-    },
-    {
-      name: "getMemory()",
-      type: "MastraMemory | undefined",
-      description:
-        "Returns the configured memory instance. Note: This is deprecated, memory should be added to agents directly.",
-      example: "const memory = mastra.getMemory();",
-    },
-    {
-      name: "getServer()",
-      type: "ServerConfig | undefined",
-      description:
-        "Returns the server configuration including port, timeout, API routes, middleware, CORS settings, and build options.",
-      example: "const serverConfig = mastra.getServer();",
-    },
-    {
-      name: "setStorage(storage)",
-      type: "void",
-      description: "Sets the storage instance for the Mastra instance.",
-      example: "mastra.setStorage(new DefaultStorage());",
-    },
-    {
-      name: "setLogger({ logger })",
-      type: "void",
-      description:
-        "Sets the logger for all components (agents, workflows, etc.).",
-      example:
-        'mastra.setLogger({ logger: new PinoLogger({ name: "MyLogger" }) });',
-    },
-    {
-      name: "setTelemetry(telemetry)",
-      type: "void",
-      description: "Sets the telemetry configuration for all components.",
-      example: 'mastra.setTelemetry({ export: { type: "console" } });',
-    },
-    {
-      name: "getLogger()",
-      type: "Logger",
-      description: "Gets the configured logger instance.",
-      example: "const logger = mastra.getLogger();",
-    },
-    {
-      name: "getTelemetry()",
-      type: "Telemetry | undefined",
-      description: "Gets the configured telemetry instance.",
-      example: "const telemetry = mastra.getTelemetry();",
-    },
-    {
-      name: "getLogsByRunId({ runId, transportId })",
-      type: "Promise<any>",
-      description: "Retrieves logs for a specific run ID and transport ID.",
-      example:
-        'const logs = await mastra.getLogsByRunId({ runId: "123", transportId: "456" });',
-    },
-    {
-      name: "getLogs(transportId)",
-      type: "Promise<any>",
-      description: "Retrieves all logs for a specific transport ID.",
-      example: 'const logs = await mastra.getLogs("transportId");',
-    },
-    {
-      name: "getMCPServers()",
-      type: "Record<string, MCPServerBase> | undefined",
-      description: "Retrieves all registered MCP server instances.",
-      example: "const mcpServers = mastra.getMCPServers();",
-    },
-  ]}
-/>
-
-## Error Handling
-
-The Mastra class methods throw typed errors that can be caught:
 
-```typescript {8} filename="example.ts" showLineNumbers
-import { mastra } from "./mastra";
 
-try {
-  const agent = mastra.getAgent("weatherAgent");
-  const result = await agent.generate("What's the weather like in London?");
-
-} catch (error) {
-  if (error instanceof Error) {
-    console.log(error.message);
-  }
-}
-```

package/.docs/raw/reference/core/setLogger.mdx

@@ -0,0 +1,47 @@
+---
+title: "Reference: Mastra.setLogger() | Core | Mastra Docs"
+description: "Documentation for the `Mastra.setLogger()` method in Mastra, which sets the logger for all components (agents, workflows, etc.)."
+---
+
+# Mastra.setLogger()
+
+The `.setLogger()` method is used to set the logger for all components (agents, workflows, etc.) in the Mastra instance. This method accepts a single object parameter with a logger property.
+
+## Usage example
+
+```typescript copy
+mastra.setLogger({ logger: new PinoLogger({ name: "testLogger" }) });
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "options",
+      type: "{ logger: TLogger }",
+      description: "An object containing the logger instance to set for all components.",
+    },
+  ]}
+/>
+
+### Options
+
+<PropertiesTable
+  content={[
+    {
+      name: "logger",
+      type: "TLogger",
+      description: "The logger instance to set for all components (agents, workflows, etc.).",
+    },
+  ]}
+/>
+
+## Returns
+
+This method does not return a value.
+
+## Related
+
+- [Logging overview](../../docs/observability/logging.mdx)
+- [Logger reference](../../reference/observability/logger.mdx)

package/.docs/raw/reference/core/setStorage.mdx

@@ -0,0 +1,39 @@
+---
+title: "Reference: Mastra.setStorage() | Core | Mastra Docs"
+description: "Documentation for the `Mastra.setStorage()` method in Mastra, which sets the storage instance for the Mastra instance."
+---
+
+# Mastra.setStorage()
+
+The `.setStorage()` method is used to set the storage instance for the Mastra instance. This method accepts a single `MastraStorage` parameter.
+
+## Usage example
+
+```typescript copy
+mastra.setStorage(
+  new LibSQLStore({
+    url: ":memory:"
+  })
+);
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "storage",
+      type: "MastraStorage",
+      description: "The storage instance to set for the Mastra instance.",
+    },
+  ]}
+/>
+
+## Returns
+
+This method does not return a value.
+
+## Related
+
+- [Storage overview](../../docs/server-db/storage.mdx)
+- [Storage reference](../../reference/storage/libsql.mdx)

package/.docs/raw/reference/core/setTelemetry.mdx

@@ -0,0 +1,35 @@
+---
+title: "Reference: Mastra.setTelemetry() | Core | Mastra Docs"
+description: "Documentation for the `Mastra.setTelemetry()` method in Mastra, which sets the telemetry configuration for all components."
+---
+
+# Mastra.setTelemetry()
+
+The `.setTelemetry()` method is used to set the telemetry configuration for all components in the Mastra instance. This method accepts a single telemetry configuration object.
+
+## Usage example
+
+```typescript copy
+mastra.setTelemetry({ export: { type: "console" } });
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "telemetry",
+      type: "OtelConfig",
+      description: "The telemetry configuration object to set for all components.",
+    },
+  ]}
+/>
+
+## Returns
+
+This method does not return a value.
+
+## Related
+
+- [Telemetry overview](../../docs/observability/telemetry.mdx)
+- [Telemetry reference](../../reference/observability/telemetry.mdx)

package/.docs/raw/reference/observability/providers/arize-ax.mdx

@@ -0,0 +1,81 @@
+---
+title: "Reference: Arize AX Integration | Mastra Observability Docs"
+description: Documentation for integrating Arize AX with Mastra, a comprehensive AI observability platform for monitoring and evaluating LLM applications.
+---
+
+# Arize AX
+
+Arize AX is a comprehensive AI observability platform designed specifically for monitoring, evaluating, and improving LLM applications in production.
+
+## Configuration
+
+To use Arize AX with Mastra, you can configure it using either environment variables or directly in your Mastra configuration.
+
+### Using Environment Variables
+
+Set the following environment variables:
+
+```env
+ARIZE_SPACE_ID="your-space-id"
+ARIZE_API_KEY="your-api-key"
+```
+
+### Getting Your Credentials
+
+1. Sign up for an Arize AX account at [app.arize.com](https://app.arize.com)
+2. Navigate to your space settings to find your Space ID and API Key
+
+## Installation
+
+First, install the OpenInference instrumentation package for Mastra:
+
+```bash
+npm install @arizeai/openinference-mastra
+```
+
+## Implementation
+
+Here's how to configure Mastra to use Arize AX with OpenTelemetry:
+
+```typescript
+import { Mastra } from "@mastra/core";
+import {
+  isOpenInferenceSpan,
+  OpenInferenceOTLPTraceExporter,
+} from "@arizeai/openinference-mastra";
+
+export const mastra = new Mastra({
+  // ... other config
+  telemetry: {
+    serviceName: "your-mastra-app",
+    enabled: true,
+    export: {
+      type: "custom",
+      exporter: new OpenInferenceOTLPTraceExporter({
+        url: "https://otlp.arize.com/v1/traces",
+        headers: {
+          "space_id": process.env.ARIZE_SPACE_ID!,
+          "api_key": process.env.ARIZE_API_KEY!,
+        },
+        spanFilter: isOpenInferenceSpan,
+      }),
+    },
+  },
+});
+```
+
+## What Gets Automatically Traced
+
+Mastra's comprehensive tracing captures:
+
+- **Agent Operations**: All agent generation, streaming, and interaction calls
+- **LLM Interactions**: Complete model calls with input/output messages and metadata
+- **Tool Executions**: Function calls made by agents with parameters and results
+- **Workflow Runs**: Step-by-step workflow execution with timing and dependencies
+- **Memory Operations**: Agent memory queries, updates, and retrieval operations
+
+All traces follow OpenTelemetry standards and include relevant metadata such as model parameters, token usage, execution timing, and error details.
+
+## Dashboard
+
+Once configured, you can view your traces and analytics in the Arize AX dashboard at [app.arize.com](https://app.arize.com)

package/.docs/raw/reference/observability/providers/arize-phoenix.mdx

@@ -0,0 +1,120 @@
+---
+title: "Reference: Arize Phoenix Integration | Mastra Observability Docs"
+description: Documentation for integrating Arize Phoenix with Mastra, an open-source AI observability platform for monitoring and evaluating LLM applications.
+---
+
+# Arize Phoenix
+
+Arize Phoenix is an open-source AI observability platform designed for monitoring, evaluating, and improving LLM applications. It can be self-hosted or used via Phoenix Cloud.
+
+## Configuration
+
+### Phoenix Cloud
+
+If you're using Phoenix Cloud, configure these environment variables:
+
+```env
+PHOENIX_API_KEY="your-phoenix-api-key"
+PHOENIX_COLLECTOR_ENDPOINT="your-phoenix-hostname"
+```
+
+#### Getting Your Credentials
+
+1. Sign up for an Arize Phoenix account at [app.phoenix.arize.com](https://app.phoenix.arize.com/login)
+2. Grab your API key from the Keys option on the left bar
+3. Note your Phoenix hostname for the collector endpoint
+
+### Self-Hosted Phoenix
+
+If you're running a self-hosted Phoenix instance, configure:
+
+```env
+PHOENIX_COLLECTOR_ENDPOINT="http://localhost:6006"
+# Optional: If authentication enabled
+PHOENIX_API_KEY="your-api-key"
+```
+
+## Installation
+
+Install the necessary packages:
+
+```bash
+npm install @arizeai/openinference-mastra@^2.2.0
+```
+
+## Implementation
+
+Here's how to configure Mastra to use Phoenix with OpenTelemetry:
+
+### Phoenix Cloud Configuration
+
+```typescript
+import { Mastra } from "@mastra/core";
+import {
+  OpenInferenceOTLPTraceExporter,
+  isOpenInferenceSpan,
+} from "@arizeai/openinference-mastra";
+
+export const mastra = new Mastra({
+  // ... other config
+  telemetry: {
+    serviceName: "my-mastra-app",
+    enabled: true,
+    export: {
+      type: "custom",
+      exporter: new OpenInferenceOTLPTraceExporter({
+        url: process.env.PHOENIX_COLLECTOR_ENDPOINT!,
+        headers: {
+          Authorization: `Bearer ${process.env.PHOENIX_API_KEY}`,
+        },
+        spanFilter: isOpenInferenceSpan,
+      }),
+    },
+  },
+});
+```
+
+### Self-Hosted Phoenix Configuration
+
+```typescript
+import { Mastra } from "@mastra/core";
+import {
+  OpenInferenceOTLPTraceExporter,
+  isOpenInferenceSpan,
+} from "@arizeai/openinference-mastra";
+
+export const mastra = new Mastra({
+  // ... other config
+  telemetry: {
+    serviceName: "my-mastra-app",
+    enabled: true,
+    export: {
+      type: "custom",
+      exporter: new OpenInferenceOTLPTraceExporter({
+        url: process.env.PHOENIX_COLLECTOR_ENDPOINT!,
+        spanFilter: isOpenInferenceSpan,
+      }),
+    },
+  },
+});
+```
+
+## What Gets Automatically Traced
+
+Mastra's comprehensive tracing captures:
+
+- **Agent Operations**: All agent generation, streaming, and interaction calls
+- **LLM Interactions**: Complete model calls with input/output messages and metadata
+- **Tool Executions**: Function calls made by agents with parameters and results
+- **Workflow Runs**: Step-by-step workflow execution with timing and dependencies
+- **Memory Operations**: Agent memory queries, updates, and retrieval operations
+
+All traces follow OpenTelemetry standards and include relevant metadata such as model parameters, token usage, execution timing, and error details.
+
+## Dashboard
+
+Once configured, you can view your traces and analytics in Phoenix:
+- **Phoenix Cloud**: [app.phoenix.arize.com](https://app.phoenix.arize.com)
+- **Self-hosted**: Your Phoenix instance URL (e.g., `http://localhost:6006`)
+
+For self-hosting options, see the [Phoenix self-hosting documentation](https://arize.com/docs/phoenix/self-hosting).

package/.docs/raw/reference/observability/providers/index.mdx

@@ -1,12 +1,14 @@
 ---
 title: "Reference: Provider List | Observability | Mastra Docs"
-description: Overview of observability providers supported by Mastra, including Dash0, SigNoz, Braintrust, Langfuse, and more.
+description: Overview of observability providers supported by Mastra, including Arize AX, Arize Phoenix, Dash0, SigNoz, Braintrust, Langfuse, and more.
 ---
 
 # Observability Providers
 
 Observability providers include:
 
+- [Arize AX](./providers/arize-ax.mdx)
+- [Arize Phoenix](./providers/arize-phoenix.mdx)
 - [Braintrust](./providers/braintrust.mdx)
 - [Dash0](./providers/dash0.mdx)
 - [Laminar](./providers/laminar.mdx)