@mastra/core 1.6.0 → 1.7.0-alpha.0

package/dist/docs/references/docs-workspace-filesystem.md

@@ -1,162 +0,0 @@
-# Filesystem
-
-**Added in:** `@mastra/core@1.1.0`
-
-Filesystem providers give agents the ability to read, write, and manage files. When you configure a filesystem on a workspace, agents receive tools for file operations.
-
-A filesystem provider handles all file operations for a workspace:
-
-- **Read** - Read file contents
-- **Write** - Create and update files
-- **List** - Browse directories
-- **Delete** - Remove files and directories
-- **Stat** - Get file metadata
-
-## Supported providers
-
-Available providers:
-
-- [`LocalFilesystem`](https://mastra.ai/reference/workspace/local-filesystem) - Stores files in a directory on disk
-- [`S3Filesystem`](https://mastra.ai/reference/workspace/s3-filesystem) - Stores files in Amazon S3 or S3-compatible storage (R2, MinIO)
-- [`GCSFilesystem`](https://mastra.ai/reference/workspace/gcs-filesystem) - Stores files in Google Cloud Storage
-
-> **Tip:** `LocalFilesystem` is the simplest way to get started as it requires no external services. For cloud storage, use `S3Filesystem` or `GCSFilesystem`.
-
-## Basic usage
-
-Create a workspace with a filesystem and assign it to an agent. The agent can then read, write, and manage files as part of its tasks:
-
-```typescript
-import { Agent } from '@mastra/core/agent';
-import { Workspace, LocalFilesystem } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({
-    basePath: './workspace',
-  }),
-});
-
-const agent = new Agent({
-  id: 'file-agent',
-  model: 'openai/gpt-4o',
-  instructions: 'You are a helpful file management assistant.',
-  workspace,
-});
-
-// The agent now has filesystem tools available
-const response = await agent.generate('List all files in the workspace');
-```
-
-## Containment
-
-By default, `LocalFilesystem` runs in **contained mode** — all file operations are restricted to stay within `basePath`. This prevents path traversal attacks and symlink escapes.
-
-In contained mode, absolute paths that fall within `basePath` are used as-is, while other absolute paths are treated as virtual paths relative to `basePath` (e.g. `/file.txt` resolves to `basePath/file.txt`). Any resolved path that escapes `basePath` throws a `PermissionError`.
-
-If your agent needs to access specific paths outside `basePath`, use `allowedPaths` to grant access without disabling containment entirely:
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({
-    basePath: './workspace',
-    allowedPaths: ['/home/user/.config', '/home/user/documents'],
-  }),
-});
-```
-
-Allowed paths can be updated at runtime using the `setAllowedPaths()` method:
-
-```typescript
-// Add a path dynamically
-workspace.filesystem.setAllowedPaths(prev => [...prev, '/home/user/documents']);
-```
-
-This is the recommended approach for least-privilege access — the agent can only reach the specific directories you allow.
-
-If your agent needs unrestricted access to the entire filesystem, disable containment:
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({
-    basePath: './workspace',
-    contained: false,
-  }),
-});
-```
-
-When `contained` is `false`, absolute paths are treated as real filesystem paths with no restriction.
-
-## Read-only mode
-
-To prevent agents from modifying files, enable read-only mode:
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({
-    basePath: './workspace',
-    readOnly: true,
-  }),
-});
-```
-
-When read-only, write tools (`write_file`, `edit_file`, `delete`, `mkdir`) are not added to the agent's toolset. The agent can still read and list files.
-
-## Mounts and CompositeFilesystem
-
-When you use the `mounts` option on a workspace, Mastra creates a `CompositeFilesystem` that routes file operations to the correct provider based on path prefix.
-
-```typescript
-import { Workspace } from '@mastra/core/workspace';
-import { S3Filesystem } from '@mastra/s3';
-import { GCSFilesystem } from '@mastra/gcs';
-import { E2BSandbox } from '@mastra/e2b';
-
-const workspace = new Workspace({
-  mounts: {
-    '/data': new S3Filesystem({
-      bucket: 'my-bucket',
-      region: 'us-east-1',
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-    }),
-    '/skills': new GCSFilesystem({
-      bucket: 'agent-skills',
-    }),
-  },
-  sandbox: new E2BSandbox({ id: 'dev-sandbox' }),
-});
-```
-
-With this configuration:
-
-- `read_file('/data/input.csv')` reads from the S3 bucket
-- `write_file('/skills/guide.md', content)` writes to the GCS bucket
-- `list_directory('/')` returns virtual entries for `/data` and `/skills`
-- Commands in the sandbox can access files at `/data` and `/skills` via FUSE mounts
-
-### Path routing
-
-All file paths must start with a mount prefix. Operations on paths that don't match any mount will fail. Listing the root directory (`/`) returns virtual directory entries for each mount point.
-
-Mount paths cannot be nested — for example, you cannot mount at both `/data` and `/data/sub`.
-
-### `filesystem` vs `mounts`
-
-`filesystem` and `mounts` are mutually exclusive options on a workspace:
-
-- Use **`filesystem`** when you have a single storage provider and don't need to mount it into a sandbox. The agent gets file tools that operate directly against the provider.
-- Use **`mounts`** when you need cloud storage accessible inside a sandbox, or when you want to combine multiple providers. The workspace creates a CompositeFilesystem for file tools and FUSE-mounts the storage into the sandbox.
-
-For local development, you typically don't need `mounts` — a `LocalFilesystem` and `LocalSandbox` pointed at the same directory gives you both file tools and command execution on the same files. See [configuration patterns](https://mastra.ai/docs/workspace/overview) for more detail.
-
-## Agent tools
-
-When you configure a filesystem on a workspace, agents receive tools for reading, writing, listing, and deleting files. See [workspace class reference](https://mastra.ai/reference/workspace/workspace-class) for details.
-
-## Related
-
-- [LocalFilesystem reference](https://mastra.ai/reference/workspace/local-filesystem)
-- [S3Filesystem reference](https://mastra.ai/reference/workspace/s3-filesystem)
-- [GCSFilesystem reference](https://mastra.ai/reference/workspace/gcs-filesystem)
-- [Workspace overview](https://mastra.ai/docs/workspace/overview)
-- [Sandbox](https://mastra.ai/docs/workspace/sandbox)

package/dist/docs/references/docs-workspace-overview.md

@@ -1,239 +0,0 @@
-# Workspaces
-
-**Added in:** `@mastra/core@1.1.0`
-
-A Mastra workspace gives agents a persistent environment for storing files and executing commands. Agents use workspace tools to read and write files, run shell commands, and search indexed content.
-
-A workspace supports the following features:
-
-- **[Filesystem](https://mastra.ai/docs/workspace/filesystem)**: File storage (read, write, list, delete)
-- **[Sandbox](https://mastra.ai/docs/workspace/sandbox)**: Command execution (shell commands)
-- **[Search](https://mastra.ai/docs/workspace/search)**: BM25, vector, or hybrid search over indexed content
-- **[Skills](https://mastra.ai/docs/workspace/skills)**: Reusable instructions for agents
-
-## How it works
-
-When you assign a workspace to an agent, Mastra includes the corresponding tools in the agent's toolset. The agent can then use these tools to interact with files and execute commands.
-
-You can create a workspace with any combination of the supported features. The agent receives only the tools relevant to what's configured.
-
-## Usage
-
-### Creating a workspace
-
-Create a workspace by instantiating the `Workspace` class with your desired features:
-
-```typescript
-import { Workspace, LocalFilesystem, LocalSandbox } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({
-    basePath: './workspace',
-  }),
-  sandbox: new LocalSandbox({
-    workingDirectory: './workspace',
-  }),
-  skills: ['/skills'],
-});
-```
-
-The `skills` array specifies paths to directories containing skill definitions, see [Skills](https://mastra.ai/docs/workspace/skills).
-
-### Global workspace
-
-Set a workspace on the Mastra instance. All agents inherit this workspace unless they define their own:
-
-```typescript
-import { Mastra } from '@mastra/core';
-import { Workspace, LocalFilesystem } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-});
-
-const mastra = new Mastra({
-  workspace,
-});
-```
-
-### Agent-scoped workspace
-
-Assign a workspace directly to an agent to override the global workspace:
-
-```typescript
-import { Agent } from '@mastra/core/agent';
-import { Workspace, LocalFilesystem } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './agent-workspace' }),
-});
-
-export const myAgent = new Agent({
-  id: 'my-agent',
-  model: 'openai/gpt-4o',
-  workspace,
-});
-```
-
-## Configuration patterns
-
-Workspaces support several configuration patterns depending on what capabilities your agent needs. The two main building blocks are `filesystem` (file tools) and `sandbox` (command execution), with `mounts` as the way to bridge cloud storage into sandboxes.
-
-### Filesystem + sandbox (local)
-
-For local development, pair a `LocalFilesystem` and `LocalSandbox` pointed at the same directory. Since both operate on the local machine, files written through the filesystem are immediately available to commands in the sandbox:
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  sandbox: new LocalSandbox({ workingDirectory: './workspace' }),
-});
-```
-
-The agent receives both file tools and `execute_command`. This is the simplest full-featured setup.
-
-### Mounts + sandbox (cloud storage)
-
-When you need cloud storage accessible inside a sandbox, use `mounts`. This FUSE-mounts the cloud filesystem into the sandbox so commands can read and write files at the mount path:
-
-```typescript
-const workspace = new Workspace({
-  mounts: {
-    '/data': new S3Filesystem({
-      bucket: 'my-bucket',
-      region: 'us-east-1',
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-    }),
-    '/skills': new GCSFilesystem({
-      bucket: 'agent-skills',
-    }),
-  },
-  sandbox: new E2BSandbox({ id: 'dev-sandbox' }),
-});
-```
-
-Under the hood, `mounts` creates a [CompositeFilesystem](https://mastra.ai/docs/workspace/filesystem) that routes file tool operations to the correct provider based on path prefix. Commands in the sandbox access the mounted paths directly (e.g., `ls /data`).
-
-You can mount multiple providers at different paths. Each mount path must be unique and non-overlapping.
-
-> **Note:** `filesystem` and `mounts` are mutually exclusive — you cannot use both in the same workspace. Use `filesystem` for a single provider without a sandbox, or `mounts` when you need to combine cloud storage with a sandbox.
-
-### Filesystem only
-
-Use a single `filesystem` when agents only need to read and write files. No command execution is available.
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new S3Filesystem({
-    bucket: 'my-bucket',
-    region: 'us-east-1',
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-  }),
-});
-```
-
-The agent receives file tools (`read_file`, `write_file`, `list_directory`, etc.) that operate directly against the storage provider.
-
-### Sandbox only
-
-Use a single `sandbox` when agents only need to execute commands. No file tools are added.
-
-```typescript
-const workspace = new Workspace({
-  sandbox: new E2BSandbox({ id: 'dev-sandbox' }),
-});
-```
-
-The agent receives the `execute_command` tool.
-
-### Which pattern should I use?
-
-| Scenario                                              | Pattern                                               |
-| ----------------------------------------------------- | ----------------------------------------------------- |
-| Local development with files and commands             | `filesystem` + `sandbox` (both local, same directory) |
-| Cloud storage accessible inside a cloud sandbox       | `mounts` + `sandbox`                                  |
-| Multiple cloud providers in one sandbox               | `mounts` + `sandbox` (one mount per provider)         |
-| Agent reads/writes files, no command execution needed | `filesystem` only                                     |
-| Agent runs commands, no file tools needed             | `sandbox` only                                        |
-
-## Tool configuration
-
-Configure tool behavior through the `tools` option on the workspace. This controls which tools are enabled and how they behave.
-
-```typescript
-import { Workspace, LocalFilesystem, LocalSandbox, WORKSPACE_TOOLS } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  sandbox: new LocalSandbox({ workingDirectory: './workspace' }),
-  tools: {
-    // Global defaults
-    enabled: true,
-    requireApproval: false,
-
-    // Per-tool overrides
-    [WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE]: {
-      requireApproval: true,
-      requireReadBeforeWrite: true,
-    },
-    [WORKSPACE_TOOLS.FILESYSTEM.DELETE]: {
-      enabled: false,
-    },
-    [WORKSPACE_TOOLS.SANDBOX.EXECUTE_COMMAND]: {
-      requireApproval: true,
-    },
-  },
-});
-```
-
-### Tool options
-
-| Option                   | Type      | Description                                                                 |
-| ------------------------ | --------- | --------------------------------------------------------------------------- |
-| `enabled`                | `boolean` | Whether the tool is available (default: `true`)                             |
-| `requireApproval`        | `boolean` | Whether the tool requires user approval before execution (default: `false`) |
-| `requireReadBeforeWrite` | `boolean` | For write tools: require reading the file first (default: `false`)          |
-
-### Read-before-write
-
-When `requireReadBeforeWrite` is enabled on write tools, agents must read a file before writing to it. This prevents overwriting files the agent hasn't seen:
-
-- **New files**: Can be written without reading (they don't exist yet)
-- **Existing files**: Must be read first
-- **Externally modified files**: If a file changed since the agent read it, the write fails
-
-## Initialization
-
-Calling `init()` is optional in most cases—some providers initialize on first operation. Call `init()` manually when using a workspace outside of Mastra (standalone scripts, tests) or when you need to pre-provision resources before the first agent interaction.
-
-```typescript
-import { Workspace, LocalFilesystem, LocalSandbox } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  sandbox: new LocalSandbox({ workingDirectory: './workspace' }),
-});
-
-// Optional: pre-create directories and sandbox before first use
-await workspace.init();
-```
-
-### What init() does
-
-Initialization runs setup logic for each configured provider:
-
-- `LocalFilesystem`: Creates the base directory if it doesn't exist
-- `LocalSandbox`: Creates the working directory
-- `Search` (if configured): Indexes files from `autoIndexPaths`, see [Search and Indexing](https://mastra.ai/docs/workspace/search)
-
-External providers may perform additional setup like establishing connections or authenticating.
-
-## Related
-
-- [Filesystem](https://mastra.ai/docs/workspace/filesystem)
-- [Sandbox](https://mastra.ai/docs/workspace/sandbox)
-- [Skills](https://mastra.ai/docs/workspace/skills)
-- [Search and indexing](https://mastra.ai/docs/workspace/search)
-- [Workspace class reference](https://mastra.ai/reference/workspace/workspace-class)

package/dist/docs/references/docs-workspace-sandbox.md

@@ -1,63 +0,0 @@
-# Sandbox
-
-**Added in:** `@mastra/core@1.1.0`
-
-Sandbox providers give agents the ability to execute shell commands. When you configure a sandbox on a workspace, agents can run commands as part of their tasks.
-
-A sandbox provider executes commands in a controlled environment:
-
-- **Command execution** - Run shell commands with arguments
-- **Working directory** - Commands run from a specific directory
-- **Environment variables** - Control what variables are available
-- **Timeouts** - Prevent long-running commands from hanging
-- **Isolation** - Optional OS-level sandboxing for security
-
-When you assign a workspace with a sandbox to an agent, Mastra automatically includes the `execute_command` tool in the agent's toolset.
-
-## Supported providers
-
-Available providers:
-
-- [`LocalSandbox`](https://mastra.ai/reference/workspace/local-sandbox) - Executes commands on the local machine
-- [`E2BSandbox`](https://mastra.ai/reference/workspace/e2b-sandbox) - Executes commands in isolated E2B cloud sandboxes
-
-## Basic usage
-
-Create a workspace with a sandbox and assign it to an agent. The agent can then execute shell commands:
-
-```typescript
-import { Agent } from '@mastra/core/agent';
-import { Workspace, LocalFilesystem, LocalSandbox } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({
-    basePath: './workspace',
-  }),
-  sandbox: new LocalSandbox({
-    workingDirectory: './workspace',
-  }),
-});
-
-const agent = new Agent({
-  id: 'dev-agent',
-  model: 'openai/gpt-4o',
-  instructions: 'You are a helpful development assistant.',
-  workspace,
-});
-
-// The agent now has the execute_command tool available
-const response = await agent.generate('Run `ls -la` in the workspace directory');
-```
-
-See [`LocalSandbox` reference](https://mastra.ai/reference/workspace/local-sandbox) for configuration options including environment isolation and native OS sandboxing.
-
-## Agent tools
-
-When you configure a sandbox on a workspace, agents receive the `execute_command` tool for running shell commands. See [workspace class reference](https://mastra.ai/reference/workspace/workspace-class) for details.
-
-## Related
-
-- [`LocalSandbox` reference](https://mastra.ai/reference/workspace/local-sandbox)
-- [`E2BSandbox` reference](https://mastra.ai/reference/workspace/e2b-sandbox)
-- [Workspace overview](https://mastra.ai/docs/workspace/overview)
-- [Filesystem](https://mastra.ai/docs/workspace/filesystem)

package/dist/docs/references/docs-workspace-search.md

@@ -1,219 +0,0 @@
-# Search and Indexing
-
-**Added in:** `@mastra/core@1.1.0`
-
-Search lets agents find relevant content in indexed workspace files. When an agent needs to answer a question or find information, it can search the indexed content instead of reading every file.
-
-## How it works
-
-Workspace search has two phases: indexing and querying.
-
-### Indexing
-
-Content must be indexed before it can be searched. When you index a document:
-
-- The content is tokenized (split into searchable terms)
-- For BM25: term frequencies and document statistics are computed
-- For vector: the content is embedded using your embedder function and stored in the vector store
-
-Each indexed document has:
-
-- **id** - A unique identifier (typically the file path)
-- **content** - The text content
-- **metadata** - Optional key-value data stored with the document
-
-### Querying
-
-When you search:
-
-1. The query is processed using the same tokenization/embedding as indexing
-2. Documents are scored based on relevance to the query
-3. Results are ranked by score and returned with the matching content
-
-Workspaces support three search modes: BM25 keyword search, vector semantic search, and hybrid search that combines both.
-
-## BM25 keyword search
-
-BM25 scores documents based on term frequency and document length. It works well for exact matches and specific terminology.
-
-```typescript
-import { Workspace, LocalFilesystem } from '@mastra/core/workspace';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  bm25: true,
-});
-```
-
-For custom BM25 parameters (`k1` is term frequency saturation, `b` is document length normalization):
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  bm25: {
-    k1: 1.5,
-    b: 0.75,
-  },
-});
-```
-
-## Vector search
-
-Vector search uses embeddings to find semantically similar content. It requires a vector store and embedder function.
-
-```typescript
-import { Workspace, LocalFilesystem } from '@mastra/core/workspace';
-import { PineconeVector } from '@mastra/pinecone';
-import { embed } from 'ai';
-import { openai } from '@ai-sdk/openai';
-
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  vectorStore: new PineconeVector({
-    apiKey: process.env.PINECONE_API_KEY,
-    index: 'workspace-index',
-  }),
-  embedder: async (text: string) => {
-    const { embedding } = await embed({
-      model: openai.embedding('text-embedding-3-small'),
-      value: text,
-    });
-    return embedding;
-  },
-});
-```
-
-## Hybrid search
-
-Configure both BM25 and vector search to enable hybrid mode, which combines keyword matching with semantic understanding.
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  bm25: true,
-  vectorStore: pineconeVector,
-  embedder: embedderFn,
-});
-```
-
-## Indexing content
-
-### Manual indexing
-
-Use `workspace.index()` to add content to the search index programmatically. The file paths become document IDs. You can also pass metadata for each document.
-
-```typescript
-// Basic indexing
-await workspace.index('/docs/guide.md', 'Content of the guide...');
-
-// Index with metadata for filtering or context
-await workspace.index('/docs/api.md', apiDocContent, {
-  metadata: {
-    category: 'api',
-    version: '2.0',
-  },
-});
-```
-
-Manual indexing is useful when:
-
-- You're indexing content that doesn't come from files (e.g., database records, API responses)
-- You want to pre-process or chunk content before indexing
-- You need to add custom metadata to documents
-
-### Auto-indexing
-
-Configure `autoIndexPaths` to automatically index files when the workspace initializes. Each path specifies a directory to index recursively.
-
-```typescript
-const workspace = new Workspace({
-  filesystem: new LocalFilesystem({ basePath: './workspace' }),
-  bm25: true,
-  autoIndexPaths: ['/docs', '/support/faq'],
-});
-
-await workspace.init();
-```
-
-When `init()` is called, all files in the specified directories are read and indexed for search. The file path becomes the document ID.
-
-> **Note:** Paths must be directories, not glob patterns. Use `/docs` to index all files in the docs directory recursively. Glob patterns like `**/*.md` are not supported.
-
-## Searching
-
-Use `workspace.search()` to find relevant content. Results are ranked by relevance score.
-
-```typescript
-const results = await workspace.search('password reset');
-
-for (const result of results) {
-  console.log(`${result.id}: ${result.score}`);
-  console.log(result.content);
-}
-```
-
-### Search options
-
-You can customize the search behavior with options:
-
-```typescript
-const results = await workspace.search('authentication flow', {
-  topK: 10,
-  mode: 'hybrid',
-  minScore: 0.5,
-  vectorWeight: 0.5,
-});
-```
-
-| Option         | Description                                                                                                   |
-| -------------- | ------------------------------------------------------------------------------------------------------------- |
-| `topK`         | Maximum number of results to return. Default: 5                                                               |
-| `mode`         | Search mode: `'bm25'`, `'vector'`, or `'hybrid'`. Defaults to the best available mode based on configuration. |
-| `minScore`     | Filter out results below this score threshold (0-1).                                                          |
-| `vectorWeight` | In hybrid mode, how much to weight vector scores vs BM25. 0 = all BM25, 1 = all vector, 0.5 = equal.          |
-
-### Search results
-
-Each result contains:
-
-```typescript
-interface SearchResult {
-  id: string; // Document ID (typically file path)
-  content: string; // The matching content
-  score: number; // Relevance score (0-1)
-  lineRange?: { // Lines where the match was found
-    start: number;
-    end: number;
-  };
-  metadata?: Record<string, unknown>; // Metadata stored with the document
-  scoreDetails?: { // Score breakdown (hybrid mode only)
-    vector?: number;
-    bm25?: number;
-  };
-}
-```
-
-**Understanding scores:**
-
-- Scores range from 0 to 1, where 1 is a perfect match
-- BM25 scores are normalized based on the best match in the result set
-- Vector scores represent cosine similarity between query and document embeddings
-- In hybrid mode, scores are combined using the `vectorWeight` parameter
-
-### When to use each mode
-
-| Mode     | Best for                             | Example queries                                                          |
-| -------- | ------------------------------------ | ------------------------------------------------------------------------ |
-| `bm25`   | Exact terms, technical queries, code | "useState hook", "404 error", "config.yaml"                              |
-| `vector` | Conceptual queries, natural language | "how to handle user authentication", "best practices for error handling" |
-| `hybrid` | General search, unknown query types  | Most agent use cases                                                     |
-
-## Agent tools
-
-When you configure search on a workspace, agents receive tools for searching and indexing content. See [workspace class reference](https://mastra.ai/reference/workspace/workspace-class) for details.
-
-## Related
-
-- [Workspace overview](https://mastra.ai/docs/workspace/overview)
-- [RAG overview](https://mastra.ai/docs/rag/overview)
-- [Workspace class reference](https://mastra.ai/reference/workspace/workspace-class)