How to Build Intelligent Agents With Mastra and MCP Integration

steps

1. Create a new Mastra project:

   bashCopy

   npx create-mastra

   • Choose a project name (e.g., meeting-assistant) and where to initialize the files.

2. Select a model provider during setup (e.g., Anthropic or OpenAI) and provide its API key.

3. Enable the recommended Mastra tools library for agent skills.

4. Initialize Git for your project, and install dependencies:

   bashCopy

   npm install

5. Start the development server:

   bashCopy

   npm run dev

   Mastra Studio should now be available at http://localhost:4111. The Studio interface lets you manage agents, tools, memory, and workflows.

steps

1. Edit your agent configuration file in Mastra (e.g., index.ts) to initialize the agent:

   typescriptCopy

   import { createAgent } from "mastra";
   
   const meetingAssistant = createAgent({
     id: "meeting-assistant",
     name: "Meeting Assistant",
     systemPrompt: `
       You are a personal meeting assistant. Your job is to help the user prepare
       for meetings by researching the people they'll meet and providing concise, actionable briefs.
       Your responses should be scannable with bullet points.
     `,
     model: "anthropic:claude-sonnet-4.5",
   });
   
   export default meetingAssistant;

2. Define the functionality your agent will serve (summarizing meeting information, facilitating event preparation, and more).

3. Restart the Mastra server using:

   bashCopy

   npm run dev

   Confirm the agent appears in Mastra Studio under Agents.

steps

1. Install Vercel's Chat SDK and Slack adapter:

   bashCopy

   npm install @vercel/chat-sdk @vercel/chat-sdk-slack

2. Configure Ngrok for local testing:

   bashCopy

   ngrok http 4111

3. Create a Slack app via the Slack developer console:

   • Use a manifest to define bot permissions (chat:write, app_mentions:read, channels:history, etc.).
   • Update the bot's event subscription URL with the Ngrok URL (e.g., https://.ngrok.io/webhook/slack).
   • Paste this URL into the Event Subscription section of your Slack app manifest.

4. Install your Slack app in a workspace, and copy the Bot Token and Signing Secret into .env:

   Copy

   SLACK_BOT_TOKEN=your-bot-token
   SLACK_SIGNING_SECRET=your-signing-secret

5. Add Slack interaction logic to the chatbot:

   typescriptCopy

   import { createSlackAdapter } from "@vercel/chat-sdk-slack";
   import { Chat } from "@vercel/chat-sdk";
   
   const slackAdapter = createSlackAdapter({
     token: process.env.SLACK_BOT_TOKEN as string,
     signingSecret: process.env.SLACK_SIGNING_SECRET as string,
   });
   
   const bot = new Chat({
     adapters: [slackAdapter],
   });
   
   bot.on("message", async (message) => {
     if (message.text.includes("prep")) {
       const response = await meetingAssistant.generate({ prompt: "Please prepare for the meeting." });
       await message.reply(response.text);
     }
   });
   
   export default bot;

6. Restart the server and test your bot in Slack by mentioning it with a message like:

   Copy

   @Meeting Assistant Prepare for a meeting

   Verify the bot successfully responds.

steps

1. Install the Exa.js library:

   bashCopy

   npm install exa.js

2. Add your EXA_API_KEY to .env:

   Copy

   EXA_API_KEY=your_exa_api_key

3. Create a tool using mastra createTool and Zod for schema validation:

   typescriptCopy

   import { createTool } from "mastra";
   import { z } from "zod";
   import Exa from "exa.js";
   
   const exa = new Exa(String(process.env.EXA_API_KEY));
   
   const searchWeb = createTool({
     id: "search-web",
     description: "Search the web for information on a person, company, or topic.",
     inputSchema: z.object({
       query: z.string(),
       numResults: z.number().default(5),
     }),
     execute: async (input) => {
       const results = await exa.searchAndContents(input.query, input.numResults);
       return results.map((r) => ({
         title: r.title,
         url: r.url,
         text: r.text,
       }));
     },
   });
   
   export default searchWeb;

4. Use the tool in your agent's setup:

   typescriptCopy

   import searchWeb from "./tools/research-tools";
   
   const meetingAssistant = createAgent({
     id: "meeting-assistant",
     name: "Meeting Assistant",
     tools: [searchWeb],
     model: "anthropic:claude-sonnet-4.5",
   });

5. Test the new tool in Slack:

   Copy

   @Meeting Assistant Research information about OpenAI

   Confirm that your agent responds with meaningful research results using Exa.ai.

steps

1. Configure episodic memory to track recent chat history:

   typescriptCopy

   import { MessageHistoryMemory } from "mastra";
   
   meetingAssistant.memory = new MessageHistoryMemory({ pastMessageCount: 10 });

2. Add working memory for storing user preferences:

   typescriptCopy

   import { WorkingMemory } from "mastra";
   
   meetingAssistant.workingMemory = new WorkingMemory({
     enabled: true,
     template: `
       {
         "name": "<user's name>",
         "role": "<user's role>",
         "company": "<user's company>",
         "topicsOfInterest": []
       }
     `,
   });

3. Enable semantic memory with embedding-based recall:

   typescriptCopy

   import { SemanticMemoryPersistence, FastEmbed } from "mastra";
   
   meetingAssistant.semanticMemory = new SemanticMemoryPersistence({
     embedder: new FastEmbed(),
     options: { topK: 3, messageRange: 2 },
   });

4. Test memory features in Slack by asking:

   Copy

   @Meeting Assistant Who have you done research on for me?

steps

1. Install Drizzle ORM for database abstraction and SQLite for storage:

   bashCopy

   npm install drizzle-orm sqlite

2. Create a new SQLite database with a scheduled_tasks schema:

   typescriptCopy

   import { drizzle } from "drizzle-orm";
   import schema from "./schema";
   
   export const db = drizzle("sqlite.db", { schema });

3. Define a task scheduling system:

   typescriptCopy

   const TaskHandlers = new Map<string, (payload: any) => Promise<void>>();
   export function registerTask(type: string, handler: (payload: any) => Promise<void>) {
     TaskHandlers.set(type, handler);
   }
   
   export async function scheduleTask({
     type,
     payload,
     scheduledAt,
   }: {
     type: string;
     payload: any;
     scheduledAt: string;
   }) {
     const task = { type, payload: JSON.stringify(payload), scheduledAt, status: "pending" };
     await db.insert("scheduled_tasks").values(task);
   }

4. Register and process the tasks:

   typescriptCopy

   registerTask("follow-up", async (payload) => {
     await bot.postToThread(payload.threadId, payload.message);
   });
   
   setInterval(async () => {
     const tasks = await db
       .selectFrom("scheduled_tasks")
       .where("status", "=", "pending")
       .where("scheduledAt", "<=", new Date().toISOString())
       .selectAll()
       .execute();
   
     for (const task of tasks) {
       const handler = TaskHandlers.get(task.type);
       if (handler) {
         await handler(JSON.parse(task.payload));
         await db
           .updateTable("scheduled_tasks")
           .set({ status: "completed" })
           .where("id", "=", task.id)
           .execute();
       }
     }
   }, 30000); // every 30 seconds

5. Schedule a follow-up reminder within cal.com webhook:

   typescriptCopy

   if (event.action === "booking.created") {
     await scheduleTask({
       type: "follow-up",
       payload: { threadId: threadId, message: "How did your meeting with [attendee name] go?" },
       scheduledAt: new Date(event.endTime).toISOString(),
     });
   }

   Test the functionality by scheduling a meeting, then verifying the follow-up occurs at the expected time.