@mastra/mcp-docs-server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/.docs/raw/reference/observability/otel-tracing/otel-config.mdx

@@ -1,117 +0,0 @@
----
-title: "Reference: OtelConfig | Mastra Observability Docs"
-description: Documentation for the OtelConfig object, which configures OpenTelemetry instrumentation, tracing, and exporting behavior.
----
-
-# `OtelConfig`
-
-The `OtelConfig` object is used to configure OpenTelemetry instrumentation, tracing, and exporting behavior within your application. By adjusting its properties, you can control how telemetry data (such as traces) is collected, sampled, and exported.
-
-To use the `OtelConfig` within Mastra, pass it as the value of the `telemetry` key when initializing Mastra. This will configure Mastra to use your custom OpenTelemetry settings for tracing and instrumentation.
-
-```typescript showLineNumbers copy
-import { Mastra } from "mastra";
-
-const otelConfig: OtelConfig = {
-  serviceName: "my-awesome-service",
-  enabled: true,
-  sampling: {
-    type: "ratio",
-    probability: 0.5,
-  },
-  export: {
-    type: "otlp",
-    endpoint: "https://otel-collector.example.com/v1/traces",
-    headers: {
-      Authorization: "Bearer YOUR_TOKEN_HERE",
-    },
-  },
-};
-```
-
-### Properties
-
-<PropertiesTable
-  content={[
-    {
-      name: "serviceName",
-      type: "string",
-      isOptional: true,
-      default: "default-service",
-      description:
-        "Human-readable name used to identify your service in telemetry backends.",
-    },
-    {
-      name: "enabled",
-      type: "boolean",
-      isOptional: true,
-      default: "true",
-      description: "Whether telemetry collection and export are enabled.",
-    },
-    {
-      name: "sampling",
-      type: "SamplingStrategy",
-      isOptional: true,
-      description:
-        "Defines the sampling strategy for traces, controlling how much data is collected.",
-      properties: [
-        {
-          name: "type",
-          type: `'ratio' | 'always_on' | 'always_off' | 'parent_based'`,
-          description: "Specifies the sampling strategy type.",
-        },
-        {
-          name: "probability",
-          type: "number (0.0 to 1.0)",
-          isOptional: true,
-          description:
-            "For `ratio` or `parent_based` strategies, defines the sampling probability.",
-        },
-        {
-          name: "root",
-          type: "object",
-          isOptional: true,
-          description:
-            "For `parent_based` strategy, configures root-level probability sampling.",
-          properties: [
-            {
-              name: "probability",
-              type: "number (0.0 to 1.0)",
-              isOptional: true,
-              description:
-                "Sampling probability for root traces in `parent_based` strategy.",
-            },
-          ],
-        },
-      ],
-    },
-    {
-      name: "export",
-      type: "object",
-      isOptional: true,
-      description: "Configuration for exporting collected telemetry data.",
-      properties: [
-        {
-          name: "type",
-          type: `'otlp' | 'console'`,
-          description:
-            "Specifies the exporter type. Use `otlp` for external exporters or `console` for development.",
-        },
-        {
-          name: "endpoint",
-          type: "string",
-          isOptional: true,
-          description:
-            "For `otlp` type, the OTLP endpoint URL to send traces to.",
-        },
-        {
-          name: "headers",
-          type: "Record<string, string>",
-          isOptional: true,
-          description:
-            "Additional headers to send with OTLP requests, useful for authentication or routing.",
-        },
-      ],
-    },
-  ]}
-/>

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

@@ -1,81 +0,0 @@
----
-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/otel-tracing/providers/arize-phoenix.mdx

@@ -1,120 +0,0 @@
----
-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/otel-tracing/providers/braintrust.mdx

@@ -1,40 +0,0 @@
----
-title: "Reference: Braintrust | Observability | Mastra Docs"
-description: Documentation for integrating Braintrust with Mastra, an evaluation and monitoring platform for LLM applications.
----
-
-# Braintrust
-
-Braintrust is an evaluation and monitoring platform for LLM applications.
-
-## Configuration
-
-To use Braintrust with Mastra, configure these environment variables:
-
-```env
-OTEL_EXPORTER_OTLP_ENDPOINT=https://api.braintrust.dev/otel
-OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <Your API Key>, x-bt-parent=project_id:<Your Project ID>"
-```
-
-## Implementation
-
-Here's how to configure Mastra to use Braintrust:
-
-```typescript
-import { Mastra } from "@mastra/core";
-
-export const mastra = new Mastra({
-  // ... other config
-  telemetry: {
-    serviceName: "your-service-name",
-    enabled: true,
-    export: {
-      type: "otlp",
-    },
-  },
-});
-```
-
-## Dashboard
-
-Access your Braintrust dashboard at [braintrust.dev](https://www.braintrust.dev/)

package/.docs/raw/reference/observability/otel-tracing/providers/dash0.mdx

@@ -1,40 +0,0 @@
----
-title: "Reference: Dash0 Integration | Mastra Observability Docs"
-description: Documentation for integrating Mastra with Dash0, an Open Telemetry native observability solution.
----
-
-# Dash0
-
-Dash0, an Open Telemetry native observability solution that provides full-stack monitoring capabilities as well as integrations with other CNCF projects like Perses and Prometheus.
-
-## Configuration
-
-To use Dash0 with Mastra, configure these environment variables:
-
-```env
-OTEL_EXPORTER_OTLP_ENDPOINT=https://ingress.<region>.dash0.com
-OTEL_EXPORTER_OTLP_HEADERS=Authorization=Bearer <your-auth-token>, Dash0-Dataset=<optional-dataset>
-```
-
-## Implementation
-
-Here's how to configure Mastra to use Dash0:
-
-```typescript
-import { Mastra } from "@mastra/core";
-
-export const mastra = new Mastra({
-  // ... other config
-  telemetry: {
-    serviceName: "your-service-name",
-    enabled: true,
-    export: {
-      type: "otlp",
-    },
-  },
-});
-```
-
-## Dashboard
-
-Access your Dash0 dashboards at [dash0.com](https://www.dash0.com/) and find out how to do more [Distributed Tracing](https://www.dash0.com/distributed-tracing) integrations in the [Dash0 Integration Hub](https://www.dash0.com/hub/integrations)

package/.docs/raw/reference/observability/otel-tracing/providers/index.mdx

@@ -1,22 +0,0 @@
----
-title: "OTLP Providers | Observability | Mastra Docs"
-description: Overview of OTLP observability providers.
----
-
-import { Callout } from "nextra/components";
-
-# OTLP Providers
-
-These providers are supported with OTLP-based tracing:
-
-- [Arize AX](./providers/arize-ax.mdx)
-- [Arize Phoenix](./providers/arize-phoenix.mdx)
-- [Braintrust](./providers/braintrust.mdx)
-- [Dash0](./providers/dash0.mdx)
-- [Laminar](./providers/laminar.mdx)
-- [Langfuse](./providers/langfuse.mdx)
-- [Langsmith](./providers/langsmith.mdx)
-- [LangWatch](./providers/langwatch.mdx)
-- [New Relic](./providers/new-relic.mdx)
-- [SigNoz](./providers/signoz.mdx)
-- [Traceloop](./providers/traceloop.mdx)

package/.docs/raw/reference/observability/otel-tracing/providers/keywordsai.mdx

@@ -1,73 +0,0 @@
----
-title: "Reference: Keywords AI Integration | Mastra Observability Docs"
-description: Documentation for integrating Keywords AI (an observability platform for LLM applications) with Mastra.
----
-
-## Keywords AI
-
-[Keywords AI](https://docs.keywordsai.co/get-started/overview) is a full-stack LLM engineering platform that helps developers and PMs build reliable AI products faster. In a shared workspace, product teams can build, monitor, and improve AI performance.
-
-This tutorial shows how to set up Keywords AI tracing with [Mastra](https://mastra.ai/) to monitor and trace your AI-powered applications.
-
-To help you get started quickly, we’ve provided a pre-built example. You can find the code [on GitHub](https://github.com/Keywords-AI/keywordsai-example-projects/tree/main/mastra-ai-weather-agent).
-
-
-## Setup
-
-Here's the tutorial about the Mastra Weather Agent example.
-
-### 1. Install Dependencies
-
-```bash copy
-pnpm install
-```
-
-### 2. Environment Variables
-
-Copy the example environment file and add your API keys:
-
-```bash copy
-cp .env.local.example .env.local
-```
-
-Update .env.local with your credentials: 
-
-```bash .env.local copy
-OPENAI_API_KEY=your-openai-api-key
-KEYWORDSAI_API_KEY=your-keywordsai-api-key
-KEYWORDSAI_BASE_URL=https://api.keywordsai.co
-```
-
-### 3. Setup Mastra client with Keywords AI tracing
-
-Configure with KeywordsAI telemetry in `src/mastra/index.ts`:
-
-```typescript filename="src/mastra/index.ts" showLineNumbers copy
-
-import { Mastra } from "@mastra/core/mastra";
-import { KeywordsAIExporter } from "@keywordsai/exporter-vercel";
-
-telemetry: {
-  serviceName: "keywordai-mastra-example",
-  enabled: true,
-  export: {
-    type: "custom",
-    exporter: new KeywordsAIExporter({
-      apiKey: process.env.KEYWORDSAI_API_KEY,
-      baseUrl: process.env.KEYWORDSAI_BASE_URL,
-      debug: true,
-    })
-  }
-}
-```
-
-### 3. Run the Project
-
-```bash copy
-mastra dev
-```
-This opens the Mastra playground where you can interact with the weather agent.
-
-## Observability
-
-Once configured, you can view your traces and analytics in the [Keywords AI platform](https://platform.keywordsai.co/platform/traces).

package/.docs/raw/reference/observability/otel-tracing/providers/laminar.mdx

@@ -1,41 +0,0 @@
----
-title: "Reference: Laminar Integration | Mastra Observability Docs"
-description: Documentation for integrating Laminar with Mastra, a specialized observability platform for LLM applications.
----
-
-# Laminar
-
-Laminar is a specialized observability platform for LLM applications.
-
-## Configuration
-
-To use Laminar with Mastra, configure these environment variables:
-
-```env
-OTEL_EXPORTER_OTLP_ENDPOINT=https://api.lmnr.ai:8443
-OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer your_api_key, x-laminar-team-id=your_team_id"
-```
-
-## Implementation
-
-Here's how to configure Mastra to use Laminar:
-
-```typescript
-import { Mastra } from "@mastra/core";
-
-export const mastra = new Mastra({
-  // ... other config
-  telemetry: {
-    serviceName: "your-service-name",
-    enabled: true,
-    export: {
-      type: "otlp",
-      protocol: "grpc",
-    },
-  },
-});
-```
-
-## Dashboard
-
-Access your Laminar dashboard at [https://lmnr.ai/](https://lmnr.ai/)

package/.docs/raw/reference/observability/otel-tracing/providers/langfuse.mdx

@@ -1,84 +0,0 @@
----
-title: "Reference: Langfuse Integration | Mastra Observability Docs"
-description: Documentation for integrating Langfuse with Mastra, an open-source observability platform for LLM applications.
----
-
-# Langfuse
-
-Langfuse is an open-source observability platform designed specifically for LLM applications.
-
-> **Note**: Currently, only AI-related calls will contain detailed telemetry data. Other operations will create traces but with limited information.
-
-## Configuration
-
-To use Langfuse 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
-OTEL_EXPORTER_OTLP_ENDPOINT="https://cloud.langfuse.com/api/public/otel/v1/traces" # 🇪🇺 EU data region
-# OTEL_EXPORTER_OTLP_ENDPOINT="https://us.cloud.langfuse.com/api/public/otel/v1/traces" # 🇺🇸 US data region
-
-OTEL_EXPORTER_OTLP_HEADERS="Authorization=Basic ${AUTH_STRING}"
-```
-
-Where `AUTH_STRING` is the base64-encoded combination of your public and secret keys (see below).
-
-### Generating AUTH_STRING
-
-The authorization uses basic auth with your Langfuse API keys. You can generate the base64-encoded auth string using:
-
-```bash
-echo -n "pk-lf-1234567890:sk-lf-1234567890" | base64
-```
-
-For long API keys on GNU systems, you may need to add `-w 0` to prevent auto-wrapping:
-
-```bash
-echo -n "pk-lf-1234567890:sk-lf-1234567890" | base64 -w 0
-```
-
-## Implementation
-
-Here's how to configure Mastra to use Langfuse with OpenTelemetry:
-
-```typescript
-import { Mastra } from "@mastra/core";
-
-export const mastra = new Mastra({
-  // ... other config
-  telemetry: {
-    enabled: true,
-    export: {
-      type: 'otlp',
-      endpoint: 'https://cloud.langfuse.com/api/public/otel/v1/traces', // or your preferred endpoint
-      headers: {
-        Authorization: `Basic ${AUTH_STRING}`, // Your base64-encoded auth string
-      },
-    },
-  },
-});
-```
-
-Alternatively, if you're using environment variables, you can simplify the configuration:
-
-```typescript
-import { Mastra } from "@mastra/core";
-
-export const mastra = new Mastra({
-  // ... other config
-  telemetry: {
-    enabled: true,
-    export: {
-      type: 'otlp',
-      // endpoint and headers will be read from OTEL_EXPORTER_OTLP_* env vars
-    },
-  },
-});
-```
-
-## Dashboard
-
-Once configured, you can view your traces and analytics in the Langfuse dashboard at [cloud.langfuse.com](https://cloud.langfuse.com)

package/.docs/raw/reference/observability/otel-tracing/providers/langsmith.mdx

@@ -1,48 +0,0 @@
----
-title: "Reference: LangSmith Integration | Mastra Observability Docs"
-description: Documentation for integrating LangSmith with Mastra, a platform for debugging, testing, evaluating, and monitoring LLM applications.
----
-
-# LangSmith
-
-LangSmith is LangChain's platform for debugging, testing, evaluating, and monitoring LLM applications.
-
-> **Note**: Currently, this integration only traces AI-related calls in your application. Other types of operations are not captured in the telemetry data.
-
-## Configuration
-
-To use LangSmith with Mastra, you'll need to configure the following environment variables:
-
-```env
-LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-LANGSMITH_API_KEY=your-api-key
-LANGSMITH_PROJECT=your-project-name
-```
-
-## Implementation
-
-Here's how to configure Mastra to use LangSmith:
-
-```typescript
-import { Mastra } from "@mastra/core";
-import { AISDKExporter } from "langsmith/vercel";
-
-export const mastra = new Mastra({
-  // ... other config
-  telemetry: {
-    serviceName: "your-service-name",
-    enabled: true,
-    export: {
-      type: "custom",
-      exporter: new AISDKExporter(),
-    },
-  },
-});
-```
-
-## Dashboard
-
-Access your traces and analytics in the LangSmith dashboard at [smith.langchain.com](https://smith.langchain.com)
-
-> **Note**: Even if you run your workflows, you may not see data appearing in a new project. You will need to sort by Name column to see all projects, select your project, then filter by LLM Calls instead of Root Runs.