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

package/.docs/raw/observability/overview.mdx

@@ -1,66 +0,0 @@
----
-title: "Overview | Observability | Mastra Docs"
-description: Monitor and debug applications with Mastra's Observability features.
----
-
-import { Callout } from "nextra/components";
-
-# Observability Overview
-
-Mastra provides comprehensive observability features designed specifically for AI applications. Monitor LLM operations, trace agent decisions, and debug complex workflows with specialized tools that understand AI-specific patterns.
-
-## Key Features
-
-### Structured Logging
-Debug applications with contextual logging:
-- **Context propagation**: Automatic correlation with traces
-- **Configurable levels**: Filter by severity in development and production
-
-### AI Tracing
-Specialized tracing for AI operations that captures:
-- **LLM interactions**: Token usage, latency, prompts, and completions
-- **Agent execution**: Decision paths, tool calls, and memory operations
-- **Workflow steps**: Branching logic, parallel execution, and step outputs
-- **Automatic instrumentation**: Zero-configuration tracing with decorators
-
-### OTEL Tracing
-Traditional distributed tracing with OpenTelemetry:
-- **Standard OTLP protocol**: Compatible with existing observability infrastructure
-- **HTTP and database instrumentation**: Automatic spans for common operations
-- **Provider integrations**: Datadog, New Relic, Jaeger, and other OTLP collectors
-- **Distributed context**: W3C Trace Context propagation
-
-## Quick Start
-
-Configure Observability in your Mastra instance:
-
-```typescript filename="src/mastra/index.ts"
-import { Mastra } from "@mastra/core";
-import { PinoLogger } from "@mastra/core";
-import { LibSqlStorage } from "@mastra/libsql";
-
-export const mastra = new Mastra({
-  // ... other config
-  logger: new PinoLogger(),
-  observability: {
-    default: { enabled: true }, // Enables AI Tracing
-  },
-  storage: new LibSQLStore({
-    url: "file:./mastra.db", // Storage is required for tracing
-  }),
-  telemetry: {
-    enabled: true, // Enables OTEL Tracing
-  }
-});
-```
-
-With this basic setup, you will see Traces and Logs in both the Playground and in Mastra Cloud.
-
-We also support various external tracing providers like Langfuse, Braintrust, and any OpenTelemetry-compatible platform (Datadog, New Relic, SigNoz, etc.). See more about this in the [AI Tracing](/docs/observability/ai-tracing.mdx) documentation.
-
-## What's Next?
-
-- **[Set up AI Tracing](/docs/observability/ai-tracing.mdx)**: Configure tracing for your application
-- **[Configure Logging](/docs/observability/logging.mdx)**: Add structured logging
-- **[View Examples](/examples/observability/basic-ai-tracing.mdx)**: See observability in action
-- **[API Reference](/reference/observability/ai-tracing/ai-tracing.mdx)**: Detailed configuration options

package/.docs/raw/rag/chunking-and-embedding.mdx

@@ -1,208 +0,0 @@
----
-title: Chunking and Embedding Documents | RAG | Mastra Docs
-description: Guide on chunking and embedding documents in Mastra for efficient processing and retrieval.
----
-
-## Chunking and Embedding Documents
-
-Before processing, create a MDocument instance from your content. You can initialize it from various formats:
-
-```ts showLineNumbers copy
-const docFromText = MDocument.fromText("Your plain text content...");
-const docFromHTML = MDocument.fromHTML("<html>Your HTML content...</html>");
-const docFromMarkdown = MDocument.fromMarkdown("# Your Markdown content...");
-const docFromJSON = MDocument.fromJSON(`{ "key": "value" }`);
-```
-
-## Step 1: Document Processing
-
-Use `chunk` to split documents into manageable pieces. Mastra supports multiple chunking strategies optimized for different document types:
-
-- `recursive`: Smart splitting based on content structure
-- `character`: Simple character-based splits
-- `token`: Token-aware splitting
-- `markdown`: Markdown-aware splitting
-- `semantic-markdown`: Markdown splitting based on related header families
-- `html`: HTML structure-aware splitting
-- `json`: JSON structure-aware splitting
-- `latex`: LaTeX structure-aware splitting
-- `sentence`: Sentence-aware splitting
-
-**Note:** Each strategy accepts different parameters optimized for its chunking approach.
-
-Here's an example of how to use the `recursive` strategy:
-
-```ts showLineNumbers copy
-const chunks = await doc.chunk({
-  strategy: "recursive",
-  maxSize: 512,
-  overlap: 50,
-  separators: ["\n"],
-  extract: {
-    metadata: true, // Optionally extract metadata
-  },
-});
-```
-
-For text where preserving sentence structure is important, here's an example of how to use the `sentence` strategy:
-
-```ts showLineNumbers copy
-const chunks = await doc.chunk({
-  strategy: "sentence",
-  maxSize: 450,
-  minSize: 50,
-  overlap: 0,
-  sentenceEnders: ["."],
-  keepSeparator: true,
-});
-```
-
-For markdown documents where preserving the semantic relationships between sections is important, here's an example of how to use the `semantic-markdown` strategy:
-
-```ts showLineNumbers copy
-const chunks = await doc.chunk({
-  strategy: "semantic-markdown",
-  joinThreshold: 500,
-  modelName: "gpt-3.5-turbo",
-});
-```
-
-**Note:** Metadata extraction may use LLM calls, so ensure your API key is set.
-
-We go deeper into chunking strategies in our [chunk documentation](/reference/rag/chunk.mdx).
-
-## Step 2: Embedding Generation
-
-Transform chunks into embeddings using your preferred provider. Mastra supports embedding models through the model router or AI SDK packages.
-
-### Using the Model Router (Recommended)
-
-The simplest way is to use Mastra's model router with `provider/model` strings:
-
-```ts showLineNumbers copy
-import { ModelRouterEmbeddingModel } from "@mastra/core";
-import { embedMany } from "ai";
-
-const embeddingModel = new ModelRouterEmbeddingModel("openai/text-embedding-3-small");
-
-const { embeddings } = await embedMany({
-  model: embeddingModel,
-  values: chunks.map((chunk) => chunk.text),
-});
-```
-
-Supported embedding models:
-- **OpenAI**: `text-embedding-3-small`, `text-embedding-3-large`, `text-embedding-ada-002`
-- **Google**: `gemini-embedding-001`, `text-embedding-004`
-
-The model router automatically handles API key detection from environment variables.
-
-### Using AI SDK Packages
-
-You can also use AI SDK embedding models directly:
-
-```ts showLineNumbers copy
-import { openai } from "@ai-sdk/openai";
-import { embedMany } from "ai";
-
-const { embeddings } = await embedMany({
-  model: openai.embedding("text-embedding-3-small"),
-  values: chunks.map((chunk) => chunk.text),
-});
-```
-
-The embedding functions return vectors, arrays of numbers representing the semantic meaning of your text, ready for similarity searches in your vector database.
-
-### Configuring Embedding Dimensions
-
-Embedding models typically output vectors with a fixed number of dimensions (e.g., 1536 for OpenAI's `text-embedding-3-small`).
-Some models support reducing this dimensionality, which can help:
-
-- Decrease storage requirements in vector databases
-- Reduce computational costs for similarity searches
-
-Here are some supported models:
-
-OpenAI (text-embedding-3 models):
-
-```ts
-const { embeddings } = await embedMany({
-  model: openai.embedding("text-embedding-3-small", {
-    dimensions: 256, // Only supported in text-embedding-3 and later
-  }),
-  values: chunks.map((chunk) => chunk.text),
-});
-```
-
-Google (text-embedding-004):
-
-```ts
-const { embeddings } = await embedMany({
-  model: google.textEmbeddingModel("text-embedding-004", {
-    outputDimensionality: 256, // Truncates excessive values from the end
-  }),
-  values: chunks.map((chunk) => chunk.text),
-});
-```
-
-### Vector Database Compatibility
-
-When storing embeddings, the vector database index must be configured to match the output size of your embedding model. If the dimensions do not match, you may get errors or data corruption.
-
-## Example: Complete Pipeline
-
-Here's an example showing document processing and embedding generation with both providers:
-
-```ts showLineNumbers copy
-import { embedMany } from "ai";
-import { openai } from "@ai-sdk/openai";
-import { cohere } from "@ai-sdk/cohere";
-
-import { MDocument } from "@mastra/rag";
-
-// Initialize document
-const doc = MDocument.fromText(`
-  Climate change poses significant challenges to global agriculture.
-  Rising temperatures and changing precipitation patterns affect crop yields.
-`);
-
-// Create chunks
-const chunks = await doc.chunk({
-  strategy: "recursive",
-  maxSize: 256,
-  overlap: 50,
-});
-
-// Generate embeddings with OpenAI
-const { embeddings: openAIEmbeddings } = await embedMany({
-  model: openai.embedding("text-embedding-3-small"),
-  values: chunks.map((chunk) => chunk.text),
-});
-
-// OR
-
-// Generate embeddings with Cohere
-const { embeddings: cohereEmbeddings } = await embedMany({
-  model: cohere.embedding("embed-english-v3.0"),
-  values: chunks.map((chunk) => chunk.text),
-});
-
-// Store embeddings in your vector database
-await vectorStore.upsert({
-  indexName: "embeddings",
-  vectors: embeddings,
-});
-```
-
-##
-
-For more examples of different chunking strategies and embedding configurations, see:
-
-- [Adjust Chunk Size](/reference/rag/chunk.mdx#adjust-chunk-size)
-- [Adjust Chunk Delimiters](/reference/rag/chunk.mdx#adjust-chunk-delimiters)
-- [Embed Text with Cohere](/reference/rag/embeddings.mdx#using-cohere)
-
-For more details on vector databases and embeddings, see:
-
-- [Vector Databases](./vector-databases.mdx)
-- [Embedding API Reference](/reference/rag/embeddings.mdx)

package/.docs/raw/rag/overview.mdx

@@ -1,87 +0,0 @@
----
-title: RAG (Retrieval-Augmented Generation) in Mastra | Mastra Docs
-description: Overview of Retrieval-Augmented Generation (RAG) in Mastra, detailing its capabilities for enhancing LLM outputs with relevant context.
----
-
-# RAG (Retrieval-Augmented Generation) in Mastra
-
-RAG in Mastra helps you enhance LLM outputs by incorporating relevant context from your own data sources, improving accuracy and grounding responses in real information.
-
-Mastra's RAG system provides:
-
-- Standardized APIs to process and embed documents
-- Support for multiple vector stores
-- Chunking and embedding strategies for optimal retrieval
-- Observability for tracking embedding and retrieval performance
-
-## Example
-
-To implement RAG, you process your documents into chunks, create embeddings, store them in a vector database, and then retrieve relevant context at query time.
-
-```ts showLineNumbers copy
-import { embedMany } from "ai";
-import { openai } from "@ai-sdk/openai";
-import { PgVector } from "@mastra/pg";
-import { MDocument } from "@mastra/rag";
-import { z } from "zod";
-
-// 1. Initialize document
-const doc = MDocument.fromText(`Your document text here...`);
-
-// 2. Create chunks
-const chunks = await doc.chunk({
-  strategy: "recursive",
-  size: 512,
-  overlap: 50,
-});
-
-// 3. Generate embeddings; we need to pass the text of each chunk
-const { embeddings } = await embedMany({
-  values: chunks.map((chunk) => chunk.text),
-  model: openai.embedding("text-embedding-3-small"),
-});
-
-// 4. Store in vector database
-const pgVector = new PgVector({
-  connectionString: process.env.POSTGRES_CONNECTION_STRING,
-});
-await pgVector.upsert({
-  indexName: "embeddings",
-  vectors: embeddings,
-}); // using an index name of 'embeddings'
-
-// 5. Query similar chunks
-const results = await pgVector.query({
-  indexName: "embeddings",
-  queryVector: queryVector,
-  topK: 3,
-}); // queryVector is the embedding of the query
-
-console.log("Similar chunks:", results);
-```
-
-This example shows the essentials: initialize a document, create chunks, generate embeddings, store them, and query for similar content.
-
-## Document Processing
-
-The basic building block of RAG is document processing. Documents can be chunked using various strategies (recursive, sliding window, etc.) and enriched with metadata. See the [chunking and embedding doc](./chunking-and-embedding.mdx).
-
-## Vector Storage
-
-Mastra supports multiple vector stores for embedding persistence and similarity search, including pgvector, Pinecone, Qdrant, and MongoDB. See the [vector database doc](./vector-databases.mdx).
-
-## Observability and Debugging
-
-Mastra's RAG system includes observability features to help you optimize your retrieval pipeline:
-
-- Track embedding generation performance and costs
-- Monitor chunk quality and retrieval relevance
-- Analyze query patterns and cache hit rates
-- Export metrics to your observability platform
-
-See the [OTel Configuration](../../reference/observability/otel-config.mdx) page for more details.
-
-## More resources
-
-- [Chain of Thought RAG Example](../../examples/rag/usage/cot-rag.mdx)
-- [All RAG Examples](../../examples/) (including different chunking strategies, embedding models, and vector stores)