@mastra/mcp-docs-server 1.1.5 → 1.1.6-alpha.0

package/.docs/docs/evals/running-in-ci.md

@@ -0,0 +1,124 @@
+# Running Scorers in CI
+
+Running scorers in your CI pipeline provides quantifiable metrics for measuring agent quality over time. The `runEvals` function processes multiple test cases through your agent or workflow and returns aggregate scores.
+
+## Basic Setup
+
+You can use any testing framework that supports ESM modules, such as [Vitest](https://vitest.dev/), [Jest](https://jestjs.io/), or [Mocha](https://mochajs.org/).
+
+## Creating Test Cases
+
+Use `runEvals` to evaluate your agent against multiple test cases. The function accepts an array of data items, each containing an `input` and optional `groundTruth` for scorer validation.
+
+```typescript
+import { describe, it, expect } from 'vitest'
+import { createScorer, runEvals } from '@mastra/core/evals'
+import { weatherAgent } from './weather-agent'
+import { locationScorer } from '../scorers/location-scorer'
+
+describe('Weather Agent Tests', () => {
+  it('should correctly extract locations from queries', async () => {
+    const result = await runEvals({
+      data: [
+        {
+          input: 'weather in Berlin',
+          groundTruth: { expectedLocation: 'Berlin', expectedCountry: 'DE' },
+        },
+        {
+          input: 'weather in Berlin, Maryland',
+          groundTruth: { expectedLocation: 'Berlin', expectedCountry: 'US' },
+        },
+        {
+          input: 'weather in Berlin, Russia',
+          groundTruth: { expectedLocation: 'Berlin', expectedCountry: 'RU' },
+        },
+      ],
+      target: weatherAgent,
+      scorers: [locationScorer],
+    })
+
+    // Assert aggregate score meets threshold
+    expect(result.scores['location-accuracy']).toBe(1)
+    expect(result.summary.totalItems).toBe(3)
+  })
+})
+```
+
+## Understanding Results
+
+The `runEvals` function returns an object with:
+
+- `scores`: Average scores for each scorer across all test cases
+- `summary.totalItems`: Total number of test cases processed
+
+```typescript
+{
+  scores: {
+    'location-accuracy': 1.0,  // Average score across all items
+    'another-scorer': 0.85
+  },
+  summary: {
+    totalItems: 3
+  }
+}
+```
+
+## Multiple Test Scenarios
+
+Create separate test cases for different evaluation scenarios:
+
+```typescript
+describe('Weather Agent Tests', () => {
+  const locationScorer = createScorer({
+    /* ... */
+  })
+
+  it('should handle location disambiguation', async () => {
+    const result = await runEvals({
+      data: [
+        {
+          input: 'weather in Berlin',
+          groundTruth: {
+            /* ... */
+          },
+        },
+        {
+          input: 'weather in Berlin, Maryland',
+          groundTruth: {
+            /* ... */
+          },
+        },
+      ],
+      target: weatherAgent,
+      scorers: [locationScorer],
+    })
+
+    expect(result.scores['location-accuracy']).toBe(1)
+  })
+
+  it('should handle typos and misspellings', async () => {
+    const result = await runEvals({
+      data: [
+        {
+          input: 'weather in Berln',
+          groundTruth: { expectedLocation: 'Berlin', expectedCountry: 'DE' },
+        },
+        {
+          input: 'weather in Parris',
+          groundTruth: { expectedLocation: 'Paris', expectedCountry: 'FR' },
+        },
+      ],
+      target: weatherAgent,
+      scorers: [locationScorer],
+    })
+
+    expect(result.scores['location-accuracy']).toBe(1)
+  })
+})
+```
+
+## Next Steps
+
+- Learn about [creating custom scorers](https://mastra.ai/docs/evals/custom-scorers)
+- Explore [built-in scorers](https://mastra.ai/docs/evals/built-in-scorers)
+- Read the [runEvals API reference](https://mastra.ai/reference/evals/run-evals)

package/.docs/docs/getting-started/build-with-ai.md

@@ -0,0 +1,68 @@
+# Build with AI
+
+AI agents may not have up-to-date knowledge about Mastra's APIs, patterns, and best practices. These resources give your AI tools direct access to current Mastra documentation, enabling them to generate accurate code and help you build faster.
+
+## Mastra Skills
+
+Agent Skills are folders of instructions, scripts, and resources that agents can discover and use to do things more accurately and efficiently. [Mastra Skills](https://mastra.ai/docs/build-with-ai/skills) contain setup instructions, best practices, and instructions on how to fetch up-to-date information from Mastra's documentation.
+
+**npm**:
+
+```bash
+npx skills add mastra-ai/skills
+```
+
+**pnpm**:
+
+```bash
+pnpm dlx skills add mastra-ai/skills
+```
+
+**Yarn**:
+
+```bash
+yarn dlx skills add mastra-ai/skills
+```
+
+**Bun**:
+
+```bash
+bun x skills add mastra-ai/skills
+```
+
+Read the dedicated [Mastra Skills](https://mastra.ai/docs/build-with-ai/skills) guide to learn more about installation options and available skills.
+
+> **Tip:** If you're just interested in giving your agent access to Mastra's documentation, we recommend using **Skills**. While the MCP Docs Server also provides this information, Skills will perform better. Use the MCP Docs Server when you need its tools, e.g. the migration tool.
+
+## MCP Docs Server
+
+In addition to documentation access, the [MCP Docs Server](https://mastra.ai/docs/build-with-ai/mcp-docs-server) also provides tools to help you migrate to newer versions of Mastra or follow the [Mastra 101 course](https://mastra.ai/course).
+
+Learn how to use the [MCP Docs Server](https://mastra.ai/docs/build-with-ai/mcp-docs-server).
+
+## Embedded package docs
+
+Mastra packages ship with embedded documentation in `dist/docs`. When you install a Mastra package, your AI agent can read these files directly from `node_modules` to understand the package's APIs and patterns.
+
+Each `dist/docs` includes:
+
+- `SKILL.md`: A skill file following the skills standard
+- `references/`: A folder with documentation files relevant to the package
+- `assets/SOURCE_MAP.json`: A source map file linking public exports to their location in `node_modules`
+
+## Context files
+
+Mastra provides a root [`llms.txt`](https://mastra.ai/llms.txt) file that contains an overview of all available documentation pages.
+
+Each documentation page also has its own `llms.txt` file. These files are streamlined markdown files. At the end of each docs page you'll find a link to the corresponding `llms.txt` file.
+
+Add `/llms.txt` to any Mastra docs URL to access it. You can also request it by adding a `.md` extension to the end of the URL.
+
+Examples for the [introduction page](https://mastra.ai/docs):
+
+- [`/docs/llms.txt`](https://mastra.ai/docs/llms.txt)
+- [`/docs.md`](https://mastra.ai/docs.md)
+
+## Mastra's documentation
+
+In addition to the [context files](#context-files) each documentation page also features a "Copy markdown" button at the top of the page. It'll copy the streamlined markdown version to your clipboard. Beside it, you'll find a dropdown menu to open the page on GitHub, in ChatGPT, Claude, and others.

package/.docs/docs/getting-started/manual-install.md

@@ -0,0 +1,226 @@
+# Manual Install
+
+> **Info:** Use this guide to manually build a standalone Mastra server step by step. In most cases, it's quicker to follow a [getting-started guide](https://mastra.ai/docs/getting-started/start), which achieves the same result using the [`mastra create`](https://mastra.ai/reference/cli/create-mastra) command. For existing projects, you can also use [`mastra init`](https://mastra.ai/reference/cli/mastra).
+
+If you prefer not to use our automatic CLI tool, you can set up your project yourself by following the guide below.
+
+1. Create a new project and change directory:
+
+   ```bash
+   mkdir my-first-agent && cd my-first-agent
+   ```
+
+   Generate a new `package.json` file:
+
+   **npm**:
+
+   ```bash
+   npm init
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm init
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn init
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun init
+   ```
+
+   Install the following dependencies:
+
+   **npm**:
+
+   ```bash
+   npm install -D typescript @types/node mastra@latest
+   npm install @mastra/core@latest zod@^4
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm add -D typescript @types/node mastra@latest
+   pnpm add @mastra/core@latest zod@^4
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn add --dev typescript @types/node mastra@latest
+   yarn add @mastra/core@latest zod@^4
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun add --dev typescript @types/node mastra@latest
+   bun add @mastra/core@latest zod@^4
+   ```
+
+   Add `dev` and `build` scripts to your `package.json` file:
+
+   ```json
+   {
+     "scripts": {
+       "test": "echo \"Error: no test specified\" && exit 1",
+       "dev": "mastra dev",
+       "build": "mastra build"
+     }
+   }
+   ```
+
+2. Create a `tsconfig.json` file:
+
+   ```bash
+   touch tsconfig.json
+   ```
+
+   Add the following configuration:
+
+   ```json
+   {
+     "compilerOptions": {
+       "target": "ES2022",
+       "module": "ES2022",
+       "moduleResolution": "bundler",
+       "esModuleInterop": true,
+       "forceConsistentCasingInFileNames": true,
+       "strict": true,
+       "skipLibCheck": true,
+       "noEmit": true,
+       "outDir": "dist"
+     },
+     "include": ["src/**/*"]
+   }
+   ```
+
+   > **Info:** Mastra requires modern `module` and `moduleResolution` settings. Using `CommonJS` or `node` will cause resolution errors.
+
+3. Create an `.env` file:
+
+   ```bash
+   touch .env
+   ```
+
+   Add your API key:
+
+   ```bash
+   GOOGLE_GENERATIVE_AI_API_KEY=<your-api-key>
+   ```
+
+   > **Note:** This guide uses Google Gemini, but you can use any supported [model provider](https://mastra.ai/models), including OpenAI, Anthropic, and more.
+
+4. Create a `weather-tool.ts` file:
+
+   ```bash
+   mkdir -p src/mastra/tools && touch src/mastra/tools/weather-tool.ts
+   ```
+
+   Add the following code:
+
+   ```ts
+   import { createTool } from '@mastra/core/tools'
+   import { z } from 'zod'
+
+   export const weatherTool = createTool({
+     id: 'get-weather',
+     description: 'Get current weather for a location',
+     inputSchema: z.object({
+       location: z.string().describe('City name'),
+     }),
+     outputSchema: z.object({
+       output: z.string(),
+     }),
+     execute: async () => {
+       return {
+         output: 'The weather is sunny',
+       }
+     },
+   })
+   ```
+
+   > **Info:** We've shortened and simplified the `weatherTool` example here. You can see the complete weather tool under [Giving an Agent a Tool](https://mastra.ai/docs/agents/using-tools).
+
+5. Create a `weather-agent.ts` file:
+
+   ```bash
+   mkdir -p src/mastra/agents && touch src/mastra/agents/weather-agent.ts
+   ```
+
+   Add the following code:
+
+   ```ts
+   import { Agent } from '@mastra/core/agent'
+   import { weatherTool } from '../tools/weather-tool'
+
+   export const weatherAgent = new Agent({
+     id: 'weather-agent',
+     name: 'Weather Agent',
+     instructions: `
+         You are a helpful weather assistant that provides accurate weather information.
+
+         Your primary function is to help users get weather details for specific locations. When responding:
+         - Always ask for a location if none is provided
+         - If the location name isn't in English, please translate it
+         - If giving a location with multiple parts (e.g. "New York, NY"), use the most relevant part (e.g. "New York")
+         - Include relevant details like humidity, wind conditions, and precipitation
+         - Keep responses concise but informative
+
+         Use the weatherTool to fetch current weather data.
+   `,
+     model: 'google/gemini-2.5-pro',
+     tools: { weatherTool },
+   })
+   ```
+
+6. Create the Mastra entry point and register your agent:
+
+   ```bash
+   touch src/mastra/index.ts
+   ```
+
+   Add the following code:
+
+   ```ts
+   import { Mastra } from '@mastra/core'
+   import { weatherAgent } from './agents/weather-agent'
+
+   export const mastra = new Mastra({
+     agents: { weatherAgent },
+   })
+   ```
+
+7. You can now launch [Studio](https://mastra.ai/docs/getting-started/studio) and test your agent.
+
+   **npm**:
+
+   ```bash
+   npm run dev
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm run dev
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn dev
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun run dev
+   ```

package/.docs/docs/getting-started/project-structure.md

@@ -0,0 +1,60 @@
+# Project Structure
+
+Your new Mastra project, created with the `create mastra` command, comes with a predefined set of files and folders to help you get started.
+
+Mastra is a framework, but it's **unopinionated** about how you organize or colocate your files. The CLI provides a sensible default structure that works well for most projects, but you're free to adapt it to your workflow or team conventions. You could even build your entire project in a single file if you wanted! Whatever structure you choose, keep it consistent to ensure your code stays maintainable and easy to navigate.
+
+## Default project structure
+
+A project created with the `create mastra` command looks like this:
+
+```text
+src/
+├── mastra/
+│   ├── agents/
+│   │   └── weather-agent.ts
+│   ├── tools/
+│   │   └── weather-tool.ts
+│   ├── workflows/
+│   │   └── weather-workflow.ts
+│   ├── scorers/
+│   │   └── weather-scorer.ts
+│   └── index.ts
+├── .env.example
+├── package.json
+└── tsconfig.json
+```
+
+> **Tip:** Use the predefined files as templates. Duplicate and adapt them to quickly create your own agents, tools, workflows, etc.
+
+### Folders
+
+Folders organize your agent's resources, like agents, tools, and workflows.
+
+| Folder                 | Description                                                                                                                              |
+| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `src/mastra`           | Entry point for all Mastra-related code and configuration.                                                                               |
+| `src/mastra/agents`    | Define and configure your agents - their behavior, goals, and tools.                                                                     |
+| `src/mastra/workflows` | Define multi-step workflows that orchestrate agents and tools together.                                                                  |
+| `src/mastra/tools`     | Create reusable tools that your agents can call                                                                                          |
+| `src/mastra/mcp`       | (Optional) Implement custom MCP servers to share your tools with external agents                                                         |
+| `src/mastra/scorers`   | (Optional) Define scorers for evaluating agent performance over time                                                                     |
+| `src/mastra/public`    | (Optional) Contents are copied into the `.build/output` directory during the build process, making them available for serving at runtime |
+
+### Top-level files
+
+Top-level files define how your Mastra project is configured, built, and connected to its environment.
+
+| File                  | Description                                                                                                                        |
+| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `src/mastra/index.ts` | Central entry point where you configure and initialize Mastra.                                                                     |
+| `.env.example`        | Template for environment variables - copy and rename to `.env` to add your secret [model provider](https://mastra.ai/models) keys. |
+| `package.json`        | Defines project metadata, dependencies, and available npm scripts.                                                                 |
+| `tsconfig.json`       | Configures TypeScript options such as path aliases, compiler settings, and build output.                                           |
+
+## Next steps
+
+- Read more about [Mastra's features](https://mastra.ai/docs).
+- Integrate Mastra with your frontend framework: [Next.js](https://mastra.ai/guides/getting-started/next-js), [React](https://mastra.ai/guides/getting-started/vite-react), or [Astro](https://mastra.ai/guides/getting-started/astro).
+- Build an agent from scratch following one of our [guides](https://mastra.ai/guides).
+- Watch conceptual guides on our [YouTube channel](https://www.youtube.com/@mastra-ai) and [subscribe](https://www.youtube.com/@mastra-ai?sub_confirmation=1)!

package/.docs/docs/getting-started/start.md

@@ -0,0 +1,28 @@
+# Start
+
+Create a new Mastra project, or integrate Mastra with your preferred framework to start building.
+
+## New project
+
+The `create mastra` command is the fastest way to build your first agent. It walks you through setup and generates an example agent you can run and adapt in [Studio](https://mastra.ai/docs/getting-started/studio) right away. You can always integrate Mastra with your framework or UI when you’re ready.
+
+- [Quickstart](https://mastra.ai/guides/getting-started/quickstart)
+
+## Integrate with your framework
+
+Add Mastra to an existing project, or scaffold a new Mastra-powered app if you’re starting from scratch.
+
+- [Next.js](https://mastra.ai/guides/getting-started/next-js)
+- [React](https://mastra.ai/guides/getting-started/vite-react)
+- [SvelteKit](https://mastra.ai/guides/getting-started/sveltekit)
+- [Astro](https://mastra.ai/guides/getting-started/astro)
+- [Nuxt](https://mastra.ai/guides/getting-started/nuxt)
+- [Express](https://mastra.ai/guides/getting-started/express)
+- [Hono](https://mastra.ai/guides/getting-started/hono)
+- [Electron](https://mastra.ai/guides/getting-started/electron)
+
+Mastra works great with agentic UI frameworks like [AI SDK UI](https://mastra.ai/guides/build-your-ui/ai-sdk-ui), [CopilotKit](https://mastra.ai/guides/build-your-ui/copilotkit), and [Assistant UI](https://mastra.ai/guides/build-your-ui/assistant-ui). Use them with any of the frontend frameworks above to stream agent responses, render tools, and build chat interfaces.
+
+## Start from a template
+
+Have a use case in mind? Start with a pre-built [template](https://mastra.ai/templates) from Mastra or our community.

package/.docs/docs/getting-started/studio.md

@@ -0,0 +1,101 @@
+# Studio
+
+Studio provides an interactive UI for building and testing your agents, along with a REST API that exposes your Mastra application as a local service. This lets you start building without worrying about integration right away.
+
+As your project evolves, Studio's development environment helps you iterate on your agent quickly. Meanwhile, Observability and Scorer features give you visibility into performance at every stage.
+
+To get started, run Studio locally using the instructions below, or [create a project in Mastra Cloud](https://mastra.ai/docs/mastra-cloud/setup) to collaborate with your team.
+
+[YouTube video player](https://www.youtube-nocookie.com/embed/ojGu6Bi4wYk)
+
+## Start Studio
+
+If you created your application with `create mastra`, start the local development server using the `dev` script. You can also run it directly with `mastra dev`.
+
+**npm**:
+
+```bash
+npm run dev
+```
+
+**pnpm**:
+
+```bash
+pnpm run dev
+```
+
+**Yarn**:
+
+```bash
+yarn dev
+```
+
+**Bun**:
+
+```bash
+bun run dev
+```
+
+Once the server's running, you can:
+
+- Open the Studio UI at <http://localhost:4111/> to test your agent interactively.
+- Visit <http://localhost:4111/swagger-ui> to discover and interact with the underlying REST API.
+
+## Studio UI
+
+The Studio UI provides an interactive development environment for you to test your agents, workflows, and tools, observe exactly what happens under the hood with each interaction, and tweak things as you go.
+
+### Agents
+
+Chat with your agent directly, dynamically switch [models](https://mastra.ai/models), and tweak settings like temperature and top-p to understand how they affect the output.
+
+When you interact with your agent, you can follow each step of its reasoning, view tool call outputs, and [observe](#observability) traces and logs to see how responses are generated. You can also attach [scorers](#scorers) to measure and compare response quality over time.
+
+### Workflows
+
+Visualize your workflow as a graph and run it step by step with a custom input. During execution, the interface updates in real time to show the active step and the path taken.
+
+When running a workflow, you can also view detailed traces showing tool calls, raw JSON outputs, and any errors that might have occurred along the way.
+
+### Tools
+
+Run tools in isolation to observe their behavior. Test them before assigning them to your agent, or isolate them to debug issues should something go wrong.
+
+### MCP
+
+List the MCP servers attached to your Mastra instance and explore their available tools.
+
+![MCP Servers Studio](/assets/images/local-dev-mcp-server-playground-8551b0af59838b2ef0bf4756ce94dcf5.jpg)
+
+### Observability
+
+When you run an agent or workflow, the Observability tab displays traces that highlight the key AI operations such as model calls, tool executions, and workflow steps. Follow these traces to see how data moves, where time is spent, and what's happening under the hood.
+
+![](https://mastra.ai/_next/image?url=%2Ftracingafter.png\&w=1920\&q=75)
+
+Tracing filters out low-level framework details so your traces stay focused and readable.
+
+### Scorers
+
+The Scorers tab displays the results of your agent's scorers as they run. When messages pass through your agent, the defined scorers evaluate each output asynchronously and render their results here. This allows you to understand how your scorers respond to different interactions, compare performance across test cases, and identify areas for improvement.
+
+## REST API
+
+The local development server exposes a complete set of REST API routes, allowing you to programmatically interact with your agents, workflows, and tools during development. This is particularly helpful if you plan to deploy the Mastra server, since the local development server uses the exact same API routes as the [Mastra Server](https://mastra.ai/docs/server/mastra-server), allowing you to develop and test against it with full parity.
+
+You can explore all available endpoints in the OpenAPI specification at <http://localhost:4111/openapi.json>, which details every endpoint and its request and response schemas.
+
+To explore the API interactively, visit the Swagger UI at <http://localhost:4111/swagger-ui>. Here, you can discover endpoints and test them directly from your browser.
+
+> **Info:** The OpenAPI and Swagger endpoints are disabled in production by default. To enable them, set [`server.build.openAPIDocs`](https://mastra.ai/reference/configuration) and [`server.build.swaggerUI`](https://mastra.ai/reference/configuration) to `true` respectively.
+
+## Configuration
+
+By default, Studio runs at <http://localhost:4111>. You can change the [`host`](https://mastra.ai/reference/configuration), [`port`](https://mastra.ai/reference/configuration), and [`studioBase`](https://mastra.ai/reference/configuration) in the Mastra server configuration. This allows you to customize where and how Studio is hosted.
+
+Furthermore, Mastra supports local HTTPS development through the [`--https`](https://mastra.ai/reference/cli/mastra) flag, which automatically creates and manages certificates for your project. When you run `mastra dev --https`, a private key and certificate are generated for localhost (or your configured host). Visit the [HTTPS reference](https://mastra.ai/reference/configuration) to learn more.
+
+## Next steps
+
+- Learn more about Mastra's suggested [project structure](https://mastra.ai/docs/getting-started/project-structure).
+- Integrate Mastra with your frontend framework of choice - [Next.js](https://mastra.ai/guides/getting-started/next-js), [React](https://mastra.ai/guides/getting-started/vite-react), or [Astro](https://mastra.ai/guides/getting-started/astro).

package/.docs/docs/index.md

@@ -0,0 +1,43 @@
+# About Mastra
+
+Mastra is a framework for building AI-powered applications and agents with a modern TypeScript stack.
+
+It includes everything you need to go from early prototypes to production-ready applications. Mastra integrates with frontend and backend frameworks like React, Next.js, and Node, or you can deploy it anywhere as a standalone server. It's the easiest way to build, tune, and scale reliable AI products.
+
+[YouTube video player](https://www.youtube-nocookie.com/embed/1qnmnRICX50)
+
+## Why Mastra?
+
+Purpose-built for TypeScript and designed around established AI patterns, Mastra gives you everything you need to build great AI applications out-of-the-box.
+
+Some highlights include:
+
+- [**Model routing**](https://mastra.ai/models): Connect to 40+ providers through one standard interface. Use models from OpenAI, Anthropic, Gemini, and more.
+
+- [**Agents**](https://mastra.ai/docs/agents/overview): Build autonomous agents that use LLMs and tools to solve open-ended tasks. Agents reason about goals, decide which tools to use, and iterate internally until the model emits a final answer or an optional stopping condition is met.
+
+- [**Workflows**](https://mastra.ai/docs/workflows/overview): When you need explicit control over execution, use Mastra's graph-based workflow engine to orchestrate complex multi-step processes. Mastra workflows use an intuitive syntax for control flow (`.then()`, `.branch()`, `.parallel()`).
+
+- [**Human-in-the-loop**](https://mastra.ai/docs/workflows/suspend-and-resume): Suspend an agent or workflow and await user input or approval before resuming. Mastra uses storage to remember execution state, so you can pause indefinitely and resume where you left off.
+
+- **Context management**: Give your agents the right context at the right time. Provide [message history](https://mastra.ai/docs/memory/message-history), [retrieve](https://mastra.ai/docs/rag/overview) data from your sources (APIs, databases, files), and add human-like [working](https://mastra.ai/docs/memory/working-memory) and [semantic](https://mastra.ai/docs/memory/semantic-recall) memory so your agents behave coherently.
+
+- **Integrations**: Bundle agents and workflows into existing React, Next.js, or Node.js apps, or ship them as standalone endpoints. When building UIs, integrate with agentic libraries like Vercel's AI SDK UI and CopilotKit to bring your AI assistant to life on the web.
+
+- **Production essentials**: Shipping reliable agents takes ongoing insight, evaluation, and iteration. With built-in [scorers](https://mastra.ai/docs/evals/overview) and [observability](https://mastra.ai/docs/observability/overview), Mastra gives you the tools to observe, measure, and refine continuously.
+
+## What can you build?
+
+- AI-powered applications that combine language understanding, reasoning, and action to solve real-world tasks.
+- Conversational agents for customer support, onboarding, or internal queries.
+- Domain-specific copilots for coding, legal, finance, research, or creative work.
+- Workflow automations that trigger, route, and complete multi-step processes.
+- Decision-support tools that analyse data and provide actionable recommendations.
+
+## Get started
+
+Choose a [getting started guide](https://mastra.ai/docs/getting-started/start) to get started, or see the [manual installation guide](https://mastra.ai/docs/getting-started/manual-install) if you need more control over your setup.
+
+If you're new to AI agents, check out our [templates](https://mastra.ai/templates), [course](https://mastra.ai/course), and [YouTube videos](https://youtube.com/@mastra-ai). You can also join our [Discord](https://discord.gg/BTYqqHKUrf) community to get help and share your projects.
+
+We can't wait to see what you build ✌️