@mastra/mcp-docs-server 0.13.0 → 0.13.1-alpha.2

package/.docs/raw/getting-started/installation.mdx

@@ -1,55 +1,28 @@
 ---
-title: "Installing Mastra Locally | Getting Started | Mastra Docs"
+title: "Installing Mastra | Getting Started | Mastra Docs"
 description: Guide on installing Mastra and setting up the necessary prerequisites for running it with various LLM providers.
 ---
 
 import { Callout, Steps } from "nextra/components";
-import YouTube from "@/components/youtube";
 import { Tabs, Tab } from "@/components/tabs";
 
-# Installing Mastra Locally
+# Install Mastra
 
-To run Mastra, you need access to an LLM. Typically, you'll want to get an API key from an LLM provider such as:
+To get started with Mastra, you’ll need access to a large language model (LLM). By default, Mastra is set up to work with [OpenAI](https://platform.openai.com/), so you’ll need an API key to begin.
 
-- [OpenAI](https://platform.openai.com/)
-- [Anthropic](https://console.anthropic.com/settings/keys)
-- [Google Gemini](https://ai.google.dev/gemini-api/docs)
+Mastra also supports other LLM providers. For a full list of supported models and setup instructions, see [Model Providers](/docs/getting-started/model-providers).
 
-You can also run Mastra with a local LLM using:
-
-- [Ollama](https://ollama.ai/).
-
-## What You'll Build
-
-By the end of this guide, you'll have built a Weather Agent that generates weather reports using OpenAI's [gpt-4o-mini](https://platform.openai.com/docs/models/gpt-4o-mini) and the Open-Meteo [forecast](https://open-meteo.com/en/docs#api_documentation) endpoint. You can run it directly from the command line or test it in the Mastra Playground. With the Weather agent running you can ask questions like:
-
-> What is the weather in London? <br/>
-> Suggest indoor alternatives in Berlin if it rains tomorrow. <br />
-> Is it windy in San Francisco today?
 
 ## Prerequisites
 
 - Node.js `v20.0` or higher
-- Access to a [supported large language model (LLM)](/docs/frameworks/ai-sdk)
-
-## Automatic Installation
-
-<YouTube id="spGlcTEjuXY" />
+- An API key from a supported [Model Provider](/docs/getting-started/model-providers)
 
 <Steps>
 
-### Create a New Project
+## Install using the `create-mastra` CLI
 
-There are two options when creating a new project with our CLI:
-
-- [Interactive](#interactive)
-- [Non-Interactive](#non-interactive)
-
-> We recommend starting a new Mastra project using the interactive setup, which guides you through scaffolding your project step by step.
-
-#### Interactive
-
-To create a project, run:
+Our CLI is the fastest way to get started with Mastra. Run the following command to start the interactive setup:
 
 {/*
 LLM CONTEXT: This Tabs component shows different package manager commands for creating a new Mastra project.
@@ -60,77 +33,68 @@ All commands achieve the same result - creating a new Mastra project with the in
 
 <Tabs items={["npx", "npm", "yarn", "pnpm", "bun"]}>
   <Tab>
-  ```bash copy
-npx create-mastra@latest
-  ```
+    ```bash copy
+    npx create-mastra@latest
+    ```
   </Tab>
   <Tab>
-  ```bash copy
-npm create mastra@latest
-   ```
-   </Tab>
+    ```bash copy
+    npm create mastra@latest
+    ```
+  </Tab>
   <Tab>
-  ```bash copy
-yarn create mastra@latest
-   ```
-   </Tab>
+    ```bash copy
+    yarn create mastra@latest
+    ```
+  </Tab>
   <Tab>
-  ```bash copy
-pnpm create mastra@latest
-  ```
+    ```bash copy
+    pnpm create mastra@latest
+    ```
   </Tab>
-<Tab>
-  ```bash copy
-bun create mastra@latest
-  ```
+  <Tab>
+    ```bash copy
+    bun create mastra@latest
+    ```
   </Tab>
 </Tabs>
 
-After the prompts, `create-mastra` will:
-
-1. Set up your project directory with TypeScript
-2. Install dependencies
-3. Configure your selected components and LLM provider
-4. Configure the MCP server in your IDE (if selected) for instant access to docs, examples, and help while you code
-
-> If you're using a different IDE, you can install the MCP server manually by following the instructions in the [MCP server docs](/docs/getting-started/mcp-docs-server). **Also** note that there are additional steps for [Cursor and Windsurf](/docs/getting-started/mcp-docs-server#after-configuration) to activate the MCP server.
 
-#### Non-Interactive
+**Install using CLI flags**
 
-You can run the Mastra CLI in fully non-interactive mode by passing all required flags, for example:
+You can also run the Mastra CLI in non-interactive mode by passing all required flags, for example:
 
 ```bash copy
 npx create-mastra@latest --project-name hello-mastra --example --components tools,agents,workflows --llm openai
 ```
 
-> See the [mastra init](/reference/cli/init) documentation for a full list of available CLI options.
+> See the [create-mastra](/reference/cli/create-mastra) documentation for a full list of available CLI options.
 
-### Set Up your API Key
+### Add your API key
 
-Create a `.env` file in your project root directory and add your API key:
+Add your API key to the `.env` file:
 
 ```bash filename=".env" copy
 OPENAI_API_KEY=<your-api-key>
 ```
+> This example uses OpenAI. Each LLM provider uses a unique name. See [Model Capabilities](/docs/getting-started/model-capability) for more information.
 
-> Replace `your-api-key` with your API key.
+You can now launch the [Mastra Development Server](/docs/local-dev/mastra-dev) and test your agent using the Mastra Playground.
 
 </Steps>
 
-## Manual Installation
+## Install manually
 
-If you prefer to set up your Mastra project manually, follow these steps:
+The following steps will walk you through installing Mastra manually.
 
 <Steps>
 
-### Create a New Project
+### Create a new project
 
 Create a new project and change directory:
 
 ```bash copy
-mkdir hello-mastra
-
-cd hello-mastra
+mkdir hello-mastra && cd hello-mastra
 ```
 
 Initialize a TypeScript project including the `@mastra/core` package:
@@ -188,10 +152,10 @@ This helps users manually set up a Mastra project with their preferred package m
 
 Add the `dev` and `build` scripts to `package.json`:
 
-```json copy
+```json filename="package.json" copy
 {
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    // ...
     "dev": "mastra dev",
     "build": "mastra build"
   }
@@ -200,9 +164,15 @@ Add the `dev` and `build` scripts to `package.json`:
 
 ### Initialize TypeScript
 
-Create a `tsconfig.json` file in your project root with the following configuration:
+Create a `tsconfig.json` file:
 
-```json copy
+```bash copy
+touch tsconfig.json
+```
+
+Add the following configuration:
+
+```json filename="tsconfig.json" copy
 {
   "compilerOptions": {
     "target": "ES2022",
@@ -212,24 +182,32 @@ Create a `tsconfig.json` file in your project root with the following configurat
     "forceConsistentCasingInFileNames": true,
     "strict": true,
     "skipLibCheck": true,
+    "noEmit": true,
     "outDir": "dist"
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", ".mastra"]
+  "include": [
+    "src/**/*"
+  ]
 }
 ```
 
 > This TypeScript configuration is optimized for Mastra projects, using modern module resolution and strict type checking.
 
-### Set Up your API Key
+### Set up your API key
+
+Create `.env` file:
 
-Create a `.env` file in your project root directory and add your API key:
+```bash copy
+touch .env
+```
+
+Add your API key:
 
 ```bash filename=".env" copy
 OPENAI_API_KEY=<your-api-key>
 ```
 
-> Replace `your-api-key` with your API key.
+> This example uses OpenAI. Each LLM provider uses a unique name. See [Model Capabilities](/docs/getting-started/model-capability) for more information.
 
 ### Create a Tool
 
@@ -245,100 +223,25 @@ Add the following code:
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
 
-interface WeatherResponse {
-  current: {
-    time: string;
-    temperature_2m: number;
-    apparent_temperature: number;
-    relative_humidity_2m: number;
-    wind_speed_10m: number;
-    wind_gusts_10m: number;
-    weather_code: number;
-  };
-}
-
 export const weatherTool = createTool({
   id: "get-weather",
   description: "Get current weather for a location",
   inputSchema: z.object({
-    location: z.string().describe("City name"),
+    location: z.string().describe("City name")
   }),
   outputSchema: z.object({
-    temperature: z.number(),
-    feelsLike: z.number(),
-    humidity: z.number(),
-    windSpeed: z.number(),
-    windGust: z.number(),
-    conditions: z.string(),
-    location: z.string(),
+    output: z.string()
   }),
-  execute: async ({ context }) => {
-    return await getWeather(context.location);
-  },
-});
-
-const getWeather = async (location: string) => {
-  const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
-  const geocodingResponse = await fetch(geocodingUrl);
-  const geocodingData = await geocodingResponse.json();
-
-  if (!geocodingData.results?.[0]) {
-    throw new Error(`Location '${location}' not found`);
+  execute: async () => {
+    return {
+      output: "The weather is sunny"
+    };
   }
-
-  const { latitude, longitude, name } = geocodingData.results[0];
-
-  const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,wind_gusts_10m,weather_code`;
-
-  const response = await fetch(weatherUrl);
-  const data: WeatherResponse = await response.json();
-
-  return {
-    temperature: data.current.temperature_2m,
-    feelsLike: data.current.apparent_temperature,
-    humidity: data.current.relative_humidity_2m,
-    windSpeed: data.current.wind_speed_10m,
-    windGust: data.current.wind_gusts_10m,
-    conditions: getWeatherCondition(data.current.weather_code),
-    location: name,
-  };
-};
-
-function getWeatherCondition(code: number): string {
-  const conditions: Record<number, string> = {
-    0: "Clear sky",
-    1: "Mainly clear",
-    2: "Partly cloudy",
-    3: "Overcast",
-    45: "Foggy",
-    48: "Depositing rime fog",
-    51: "Light drizzle",
-    53: "Moderate drizzle",
-    55: "Dense drizzle",
-    56: "Light freezing drizzle",
-    57: "Dense freezing drizzle",
-    61: "Slight rain",
-    63: "Moderate rain",
-    65: "Heavy rain",
-    66: "Light freezing rain",
-    67: "Heavy freezing rain",
-    71: "Slight snow fall",
-    73: "Moderate snow fall",
-    75: "Heavy snow fall",
-    77: "Snow grains",
-    80: "Slight rain showers",
-    81: "Moderate rain showers",
-    82: "Violent rain showers",
-    85: "Slight snow showers",
-    86: "Heavy snow showers",
-    95: "Thunderstorm",
-    96: "Thunderstorm with slight hail",
-    99: "Thunderstorm with heavy hail",
-  };
-  return conditions[code] || "Unknown";
-}
+});
 ```
 
+> See the full weatherTool example in [Giving an Agent a Tool](/examples/agents/using-a-tool).
+
 ### Create an Agent
 
 Create a `weather-agent.ts` file:
@@ -355,226 +258,25 @@ import { Agent } from "@mastra/core/agent";
 import { weatherTool } from "../tools/weather-tool";
 
 export const weatherAgent = new 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
-- Include relevant details like humidity, wind conditions, and precipitation
-- Keep responses concise but informative
-
-Use the weatherTool to fetch current weather data.`,
-  model: openai("gpt-4o-mini"),
-  tools: { weatherTool },
-});
-```
-
-### Create a Workflow
-
-Create a `weather-workflow.ts` file:
-
-```bash copy
-mkdir -p src/mastra/workflows && touch src/mastra/workflows/weather-workflow.ts
-```
-
-Add the following code:
-
-```ts filename="src/mastra/workflows/weather-workflow.ts" showLineNumbers copy
-import { openai } from "@ai-sdk/openai";
-import { Agent } from "@mastra/core/agent";
-import { createStep, createWorkflow } from "@mastra/core/workflows";
-import { z } from "zod";
-
-const llm = openai("gpt-4o-mini");
-
-const agent = new Agent({
-  name: "Weather Agent",
-  model: llm,
+  name: 'Weather Agent',
   instructions: `
-        You are a local activities and travel expert who excels at weather-based planning. Analyze the weather data and provide practical activity recommendations.
-
-        For each day in the forecast, structure your response exactly as follows:
-
-        📅 [Day, Month Date, Year]
-        ═══════════════════════════
-
-        🌡️ WEATHER SUMMARY
-        • Conditions: [brief description]
-        • Temperature: [X°C/Y°F to A°C/B°F]
-        • Precipitation: [X% chance]
-
-        🌅 MORNING ACTIVITIES
-        Outdoor:
-        • [Activity Name] - [Brief description including specific location/route]
-          Best timing: [specific time range]
-          Note: [relevant weather consideration]
-
-        🌞 AFTERNOON ACTIVITIES
-        Outdoor:
-        • [Activity Name] - [Brief description including specific location/route]
-          Best timing: [specific time range]
-          Note: [relevant weather consideration]
-
-        🏠 INDOOR ALTERNATIVES
-        • [Activity Name] - [Brief description including specific venue]
-          Ideal for: [weather condition that would trigger this alternative]
-
-        ⚠️ SPECIAL CONSIDERATIONS
-        • [Any relevant weather warnings, UV index, wind conditions, etc.]
-
-        Guidelines:
-        - Suggest 2-3 time-specific outdoor activities per day
-        - Include 1-2 indoor backup options
-        - For precipitation >50%, lead with indoor activities
-        - All activities must be specific to the location
-        - Include specific venues, trails, or locations
-        - Consider activity intensity based on temperature
-        - Keep descriptions concise but informative
-
-        Maintain this exact formatting for consistency, using the emoji and section headers as shown.
-      `,
-});
-
-const forecastSchema = z.object({
-  date: z.string(),
-  maxTemp: z.number(),
-  minTemp: z.number(),
-  precipitationChance: z.number(),
-  condition: z.string(),
-  location: z.string(),
-});
-
-function getWeatherCondition(code: number): string {
-  const conditions: Record<number, string> = {
-    0: "Clear sky",
-    1: "Mainly clear",
-    2: "Partly cloudy",
-    3: "Overcast",
-    45: "Foggy",
-    48: "Depositing rime fog",
-    51: "Light drizzle",
-    53: "Moderate drizzle",
-    55: "Dense drizzle",
-    61: "Slight rain",
-    63: "Moderate rain",
-    65: "Heavy rain",
-    71: "Slight snow fall",
-    73: "Moderate snow fall",
-    75: "Heavy snow fall",
-    95: "Thunderstorm",
-  };
-  return conditions[code] || "Unknown";
-}
-
-const fetchWeather = createStep({
-  id: "fetch-weather",
-  description: "Fetches weather forecast for a given city",
-  inputSchema: z.object({
-    city: z.string().describe("The city to get the weather for"),
-  }),
-  outputSchema: forecastSchema,
-  execute: async ({ inputData }) => {
-    if (!inputData) {
-      throw new Error("Input data not found");
-    }
-
-    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(inputData.city)}&count=1`;
-    const geocodingResponse = await fetch(geocodingUrl);
-    const geocodingData = (await geocodingResponse.json()) as {
-      results: { latitude: number; longitude: number; name: string }[];
-    };
-
-    if (!geocodingData.results?.[0]) {
-      throw new Error(`Location '${inputData.city}' not found`);
-    }
-
-    const { latitude, longitude, name } = geocodingData.results[0];
-
-    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m`;
-    const response = await fetch(weatherUrl);
-    const data = (await response.json()) as {
-      current: {
-        time: string;
-        precipitation: number;
-        weathercode: number;
-      };
-      hourly: {
-        precipitation_probability: number[];
-        temperature_2m: number[];
-      };
-    };
-
-    const forecast = {
-      date: new Date().toISOString(),
-      maxTemp: Math.max(...data.hourly.temperature_2m),
-      minTemp: Math.min(...data.hourly.temperature_2m),
-      condition: getWeatherCondition(data.current.weathercode),
-      precipitationChance: data.hourly.precipitation_probability.reduce(
-        (acc, curr) => Math.max(acc, curr),
-        0,
-      ),
-      location: inputData.city,
-    };
-
-    return forecast;
-  },
+      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: openai('gpt-4o-mini'),
+  tools: { weatherTool }
 });
-
-const planActivities = createStep({
-  id: "plan-activities",
-  description: "Suggests activities based on weather conditions",
-  inputSchema: forecastSchema,
-  outputSchema: z.object({
-    activities: z.string(),
-  }),
-  execute: async ({ inputData }) => {
-    const forecast = inputData;
-
-    if (!forecast) {
-      throw new Error("Forecast data not found");
-    }
-
-    const prompt = `Based on the following weather forecast for ${forecast.location}, suggest appropriate activities:
-      ${JSON.stringify(forecast, null, 2)}
-      `;
-
-    const response = await agent.stream([
-      {
-        role: "user",
-        content: prompt,
-      },
-    ]);
-
-    let activitiesText = "";
-
-    for await (const chunk of response.textStream) {
-      process.stdout.write(chunk);
-      activitiesText += chunk;
-    }
-
-    return {
-      activities: activitiesText,
-    };
-  },
-});const weatherWorkflow = createWorkflow({
-  id: "weather-workflow",
-  inputSchema: z.object({
-    city: z.string().describe("The city to get the weather for"),
-  }),
-  outputSchema: z.object({
-    activities: z.string(),
-  }),
-})
-  .then(fetchWeather)
-  .then(planActivities);
-
-weatherWorkflow.commit();
-
-export { weatherWorkflow };
 ```
 
-### Register Agent
+### Register the Agent
 
 Create the Mastra entry point and register agent:
 
@@ -585,197 +287,35 @@ touch src/mastra/index.ts
 Add the following code:
 
 ```ts filename="src/mastra/index.ts" showLineNumbers copy
-import { Mastra } from "@mastra/core";
-import { PinoLogger } from "@mastra/loggers";
-import { LibSQLStore } from "@mastra/libsql";
-import { weatherWorkflow } from "./workflows/weather-workflow";
+import { Mastra } from "@mastra/core/mastra";
 import { weatherAgent } from "./agents/weather-agent";
 
 export const mastra = new Mastra({
-  workflows: { weatherWorkflow },
-  agents: { weatherAgent },
-  storage: new LibSQLStore({
-    // stores telemetry, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
-    url: ":memory:",
-  }),
-  logger: new PinoLogger({
-    name: "Mastra",
-    level: "info",
-  }),
+  agents: { weatherAgent }
 });
 ```
 
-> This registers your agent with Mastra so that `mastra dev` can discover and serve it.
+You can now launch the [Mastra Development Server](/docs/local-dev/mastra-dev) and test your agent using the Mastra Playground.
 
 </Steps>
 
-## Start the Mastra Server
-
-Mastra provides commands to serve your agents via REST endpoints
-
-### Development Server
-
-Run the following command to start the Mastra server:
-
-```bash copy
-npm run dev
-```
-
-If you have the mastra CLI installed, run:
-
-```bash copy
-mastra dev
-```
-
-This command creates REST API endpoints for your agents which are available on the following links:
-
-- Playground: [http://localhost:4111/](http://localhost:4111/)
-- Mastra API: [http://localhost:4111/api](http://localhost:4111/api)
-- OpenAPI Spec: [http://localhost:4111/openapi.json](http://localhost:4111/openapi.json)
-- Swagger UI – API explorer: [http://localhost:4111/swagger-ui](http://localhost:4111/swagger-ui)
-
-### Test the Endpoint
-
-You can also test the agent's endpoint using `curl` or `fetch`:
-
-<Tabs items={['curl', 'fetch']}>
-  <Tab>
-```bash copy
-curl -X POST http://localhost:4111/api/agents/weatherAgent/generate \
--H "Content-Type: application/json" \
--d '{"messages": ["What is the weather in London?"]}'
-```
-  </Tab>
-  <Tab>
-```js copy showLineNumbers
-fetch('http://localhost:4111/api/agents/weatherAgent/generate', {
-  method: 'POST',
-  headers: {
-    'Content-Type': 'application/json',
-  },
-  body: JSON.stringify({
-    messages: ['What is the weather in London?'],
-  }),
-})
-  .then(response => response.json())
-  .then(data => {
-    console.log('Agent response:', data.text);
-  })
-  .catch(error => {
-    console.error('Error:', error);
-  });
-```
-  </Tab>
-</Tabs>
-
-### Run from the command line
-
-If you'd like to call agents directly from the command line, create a simple script to get and invoke an agent.
-
-Create a test file:
-
-```bash copy
-touch src/test-agent.ts
-```
-
-Install `dotenv` to load environment variables (e.g. your API keys):
-
-<Tabs items={["npm", "pnpm", "yarn", "bun"]}>
-  <Tab>
-  ```bash copy 
-  npm install dotenv --save-dev 
-  ```
-  </Tab>
-  <Tab>
-  ```bash copy 
-  pnpm add dotenv --save-dev 
-  ```
-  </Tab>
-  <Tab>
-  ```bash copy 
-  yarn add dotenv --dev 
-  ```
-  </Tab>
-  <Tab>
-  ```bash copy 
-  bun add dotenv --dev 
-  ```
-  </Tab>
-</Tabs>
-
-If you're using a `.env` file, add the following code:
-
-```ts filename="src/test-agent.ts" showLineNumbers copy
-import "dotenv/config";
-
-import { mastra } from "./mastra";
-
-async function main() {
-  const agent = await mastra.getAgent("weatherAgent");
-
-  const result = await agent.generate("What is the weather in London?");
-
-  console.log("Agent response:", result.text);
-}
-
-main();
-```
-
-Or, if you're using a `.env.development` file, add the following code:
-
-```ts filename="src/test-agent.ts" showLineNumbers copy
-import { config } from "dotenv";
-config({ path: ".env.development" });
-
-import { mastra } from "./mastra";
-
-async function main() {
-  const agent = await mastra.getAgent("weatherAgent");
-
-  const result = await agent.generate("What is the weather in London?");
-
-  console.log("Agent response:", result.text);
-}
-
-main();
-```
-
-Run the script to test the agent:
-
-```bash copy
-npx tsx src/test-agent.ts
-```
-
-You should see output similar to the following:
-
-```plaintext
-Agent response: The current weather in London is as follows:
-
-- **Temperature:** 12.9°C (Feels like 9.7°C)
-- **Humidity:** 63%
-- **Wind Speed:** 14.7 km/h
-- **Wind Gusts:** 32.4 km/h
-- **Conditions:** Overcast
-
-Let me know if you need more information!
-```
-
-## Use Mastra on the Client
-
-To use Mastra in your frontend applications, use our type-safe client SDK to call your agents via the Mastra REST API.
-
-- [Mastra Client SDK](/docs/deployment/client)
+## Add to an existing project
 
-## Existing Project Installation
+Mastra can be installed and integrated into a wide range of projects. Below are links to integration guides to help you get started:
 
-To add Mastra to an existing project, see our Local development docs:
+- [Next.js](/docs/frameworks/web-frameworks/next-js)
+- [Vite + React](/docs/frameworks/web-frameworks/vite-react)
+- [Astro](/docs/frameworks/web-frameworks/astro)
+- [Express](/docs/frameworks/servers/express)
 
-- [Adding to an Existing Project](/docs/local-dev/add-to-existing-project)
 
-## Next Steps
+### `mastra init`
 
-- [Deploy your Agent to Mastra Cloud](/docs/deployment/overview)
-- [Integrate Mastra in your Next.js project](/docs/frameworks/next-js)
+To install Mastra in an existing project, use the `mastra init` command.
 
+> See [mastra init](/reference/cli/init) for more information.
 
+## Next steps
 
+- [Local Development](/docs/local-dev/mastra-dev)
+- [Deploy to Mastra Cloud](/docs/deployment/overview)