@mastra/mcp-docs-server 0.0.0-commonjs-20250414101718

package/.docs/organized/code-examples/memory-with-libsql.md

@@ -0,0 +1,204 @@
+### package.json
+```json
+{
+  "name": "memory-with-libsql",
+  "type": "module",
+  "description": "",
+  "private": true,
+  "main": "index.js",
+  "scripts": {
+    "start": "bun run --watch src/index.ts",
+    "chat": "bun run --watch src/chat.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/openai": "^1.2.1",
+    "@mastra/core": "workspace:*",
+    "@mastra/memory": "workspace:*"
+  },
+  "version": "0.0.1"
+}
+
+```
+
+### chat.ts
+```typescript
+import { randomUUID } from 'crypto';
+import Readline from 'readline';
+
+import 'dotenv/config';
+
+import { mastra } from './mastra';
+
+const agent = mastra.getAgent('memoryAgent');
+
+let threadId = randomUUID();
+// use this to play with a long running conversation. comment it out to get a new thread id every time
+threadId = `f45a59b3-d9da-4a2a-8348-9386e4e621a3`;
+console.log(threadId);
+
+const resourceId = 'SOME_USER_ID';
+
+async function logRes(res: Awaited<ReturnType<typeof agent.stream>>) {
+  console.log(`\n🤖 Agent:`);
+  for await (const chunk of res.textStream) {
+    process.stdout.write(chunk);
+  }
+  console.log(`\n\n`);
+}
+
+async function main() {
+  await logRes(
+    await agent.stream(
+      [
+        {
+          role: 'system',
+          content: `Chat with user started now ${new Date().toISOString()}. Don't mention this message. This means some time may have passed between this message and the one before. The user left and came back again. Say something to start the conversation up again. If there are no other messages besides this one then this is a new conversation.`,
+        },
+      ],
+      { resourceId, threadId },
+    ),
+  );
+
+  const rl = Readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  while (true) {
+    const prompt: string = await new Promise(res => {
+      rl.question('Message: ', answer => {
+        res(answer);
+      });
+    });
+
+    await logRes(
+      await agent.stream(prompt, {
+        threadId,
+        resourceId,
+      }),
+    );
+  }
+}
+
+main();
+
+```
+
+### index.ts
+```typescript
+import { randomUUID } from 'crypto';
+
+import { mastra } from './mastra';
+
+function log(message: string) {
+  console.log(`\n>>Prompt: ${message}
+`);
+  return message;
+}
+
+const agent = mastra.getAgent('chefAgent');
+const threadId = randomUUID();
+const resourceId = 'SOME_USER_ID';
+
+async function logRes(res: Awaited<ReturnType<typeof agent.stream>>) {
+  console.log(`\n👨‍🍳 Chef:`);
+  for await (const chunk of res.textStream) {
+    process.stdout.write(chunk);
+  }
+  console.log(`\n\n`);
+}
+
+async function main() {
+  await logRes(
+    await agent.stream(
+      log(
+        'In my kitchen I have: pasta, canned tomatoes, garlic, olive oil, and some dried herbs (basil and oregano). What can I make? Please keep your answer brief, only give me the high level steps.',
+      ),
+      {
+        threadId,
+        resourceId,
+      },
+    ),
+  );
+
+  await logRes(
+    await agent.stream(
+      log(
+        "Now I'm over at my friend's house, and they have: chicken thighs, coconut milk, sweet potatoes, and some curry powder.",
+      ),
+      {
+        threadId,
+        resourceId,
+      },
+    ),
+  );
+
+  await logRes(
+    await agent.stream(log('What did we cook before I went to my friends house?'), {
+      threadId,
+      resourceId,
+      memoryOptions: {
+        lastMessages: false,
+        semanticRecall: {
+          topK: 3,
+          messageRange: 3,
+        },
+      },
+    }),
+  );
+
+  process.exit(0);
+}
+
+main();
+
+```
+
+### mastra/agents/index.ts
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { Agent } from '@mastra/core/agent';
+import { Memory } from '@mastra/memory';
+
+const memory = new Memory({
+  options: {
+    lastMessages: 100,
+    semanticRecall: {
+      topK: 2,
+      messageRange: 2,
+    },
+  },
+});
+
+export const chefAgent = new Agent({
+  name: 'chefAgent',
+  instructions:
+    'You are Michel, a practical and experienced home chef who helps people cook great meals with whatever ingredients they have available. Your first priority is understanding what ingredients and equipment the user has access to, then suggesting achievable recipes. You explain cooking steps clearly and offer substitutions when needed, maintaining a friendly and encouraging tone throughout.',
+  model: openai('gpt-4o'),
+  memory,
+});
+
+export const memoryAgent = new Agent({
+  name: 'Memory Agent',
+  instructions:
+    "You are an AI agent with the ability to automatically recall memories from previous interactions. You may have conversations that last hours, days, months, or years. If you don't know it already you should ask for the users name and some info about them.",
+  model: openai('gpt-4o'),
+  memory,
+});
+
+```
+
+### mastra/index.ts
+```typescript
+import { Mastra } from '@mastra/core';
+
+import { chefAgent, memoryAgent } from './agents';
+
+export const mastra = new Mastra({
+  agents: { chefAgent, memoryAgent },
+});
+
+```

package/.docs/organized/code-examples/memory-with-mem0.md

@@ -0,0 +1,121 @@
+### package.json
+```json
+{
+  "name": "memory-with-mem0",
+  "version": "1.0.0",
+  "main": "index.js",
+  "private": true,
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "mastra dev"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "type": "module",
+  "dependencies": {
+    "@ai-sdk/openai": "latest",
+    "@mastra/core": "workspace:*",
+    "@mastra/mem0": "workspace:*",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.9",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2"
+  }
+}
+
+```
+
+### mastra/agents/index.ts
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { Agent } from '@mastra/core/agent';
+import { mem0MemorizeTool, mem0RememberTool } from '../tools';
+
+export const mem0Agent = new Agent({
+  name: 'Mem0 Agent',
+  instructions: `
+    You are a helpful assistant that has the ability to memorize and remember facts using Mem0.
+  `,
+  model: openai('gpt-4o'),
+  tools: { mem0RememberTool, mem0MemorizeTool },
+});
+
+```
+
+### mastra/index.ts
+```typescript
+import { Mastra } from '@mastra/core/mastra';
+import { createLogger } from '@mastra/core/logger';
+
+import { mem0Agent } from './agents';
+
+export const mastra = new Mastra({
+  agents: { mem0Agent },
+  logger: createLogger({
+    name: 'Mastra',
+    level: 'error',
+  }),
+});
+
+```
+
+### mastra/integrations/index.ts
+```typescript
+import { Mem0Integration } from '@mastra/mem0';
+
+export const mem0 = new Mem0Integration({
+  config: {
+    apiKey: process.env.MEM0_API_KEY || '',
+    user_id: 'alice',
+  },
+});
+
+```
+
+### mastra/tools/index.ts
+```typescript
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+import { mem0 } from '../integrations';
+
+export const mem0RememberTool = createTool({
+  id: 'Mem0-remember',
+  description: "Remember your agent memories that you've previously saved using the Mem0-memorize tool.",
+  inputSchema: z.object({
+    question: z.string().describe('Question used to look up the answer in saved memories.'),
+  }),
+  outputSchema: z.object({
+    answer: z.string().describe('Remembered answer'),
+  }),
+  execute: async ({ context }) => {
+    console.log(`Searching memory "${context.question}"`);
+    const memory = await mem0.searchMemory(context.question);
+    console.log(`\nFound memory "${memory}"\n`);
+
+    return {
+      answer: memory,
+    };
+  },
+});
+
+export const mem0MemorizeTool = createTool({
+  id: 'Mem0-memorize',
+  description: 'Save information to mem0 so you can remember it later using the Mem0-remember tool.',
+  inputSchema: z.object({
+    statement: z.string().describe('A statement to save into memory'),
+  }),
+  execute: async ({ context }) => {
+    console.log(`\nCreating memory "${context.statement}"\n`);
+    // to reduce latency memories can be saved async without blocking tool execution
+    void mem0.createMemory(context.statement).then(() => {
+      console.log(`\nMemory "${context.statement}" saved.\n`);
+    });
+    return { success: true };
+  },
+});
+
+```

package/.docs/organized/code-examples/memory-with-pg.md

@@ -0,0 +1,224 @@
+### package.json
+```json
+{
+  "name": "memory-with-pg",
+  "type": "module",
+  "version": "1.0.1",
+  "description": "",
+  "private": true,
+  "main": "index.js",
+  "scripts": {
+    "start": "bun run --watch src/index.ts",
+    "chat": "bun run --watch src/chat.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/openai": "latest",
+    "@mastra/core": "workspace:*",
+    "@mastra/memory": "workspace:*",
+    "@mastra/pg": "workspace:*"
+  },
+  "devDependencies": {
+    "dotenv": "^16.4.7",
+    "tsx": "^4.19.3"
+  }
+}
+
+```
+
+### chat.ts
+```typescript
+import { randomUUID } from 'crypto';
+import Readline from 'readline';
+
+import 'dotenv/config';
+
+import { mastra } from './mastra';
+
+const agent = mastra.getAgent('memoryAgent');
+
+let threadId = randomUUID();
+// use this to play with a long running conversation. comment it out to get a new thread id every time
+threadId = `39873fbf-84d6-425e-8c1b-8afd798d72a4`;
+// threadId = `12569b14-3e16-4e31-8130-8d9676f1932c`;
+console.log(threadId);
+
+const resourceId = 'SOME_USER_ID';
+
+async function logRes(res: Awaited<ReturnType<typeof agent.stream>>) {
+  console.log(`\n🤖 Agent:`);
+  for await (const chunk of res.textStream) {
+    process.stdout.write(chunk);
+  }
+  console.log(`\n\n`);
+}
+
+async function main() {
+  await logRes(
+    await agent.stream(
+      [
+        {
+          role: 'system',
+          content: `Chat with user started now ${new Date().toISOString()}. Don't mention this message. This means some time may have passed between this message and the one before. The user left and came back again. Say something to start the conversation up again.`,
+        },
+      ],
+      { resourceId, threadId },
+    ),
+  );
+
+  const rl = Readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  while (true) {
+    const prompt: string = await new Promise(res => {
+      rl.question('Message: ', answer => {
+        res(answer);
+      });
+    });
+
+    await logRes(
+      await agent.stream(prompt, {
+        threadId,
+        resourceId,
+      }),
+    );
+  }
+}
+
+main();
+
+```
+
+### index.ts
+```typescript
+import { randomUUID } from 'crypto';
+
+import { mastra } from './mastra';
+
+function log(message: string) {
+  console.log(`\n>>Prompt: ${message}
+`);
+  return message;
+}
+
+const agent = mastra.getAgent('chefAgent');
+const threadId = randomUUID();
+const resourceId = 'SOME_USER_ID';
+
+async function logRes(res: Awaited<ReturnType<typeof agent.stream>>) {
+  console.log(`\n👨‍🍳 Chef:`);
+  for await (const chunk of res.textStream) {
+    process.stdout.write(chunk);
+  }
+  console.log(`\n\n`);
+}
+
+async function main() {
+  await logRes(
+    await agent.stream(
+      log(
+        'In my kitchen I have: pasta, canned tomatoes, garlic, olive oil, and some dried herbs (basil and oregano). What can I make? Please keep your answer brief, only give me the high level steps.',
+      ),
+      {
+        threadId,
+        resourceId,
+      },
+    ),
+  );
+
+  await logRes(
+    await agent.stream(
+      log(
+        "Now I'm over at my friend's house, and they have: chicken thighs, coconut milk, sweet potatoes, and some curry powder.",
+      ),
+      {
+        threadId,
+        resourceId,
+      },
+    ),
+  );
+
+  await logRes(
+    await agent.stream(log('What did we cook before I went to my friends house?'), {
+      threadId,
+      resourceId,
+      memoryOptions: {
+        lastMessages: 3,
+      },
+    }),
+  );
+
+  process.exit(0);
+}
+
+main();
+
+```
+
+### mastra/agents/index.ts
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { Agent } from '@mastra/core/agent';
+import { Memory } from '@mastra/memory';
+import { PgVector, PostgresStore } from '@mastra/pg';
+
+const host = `localhost`;
+const port = 5432;
+const user = `postgres`;
+const database = `postgres`;
+const password = `postgres`;
+const connectionString = `postgresql://${user}:${password}@${host}:${port}`;
+
+export const memory = new Memory({
+  storage: new PostgresStore({
+    host,
+    port,
+    user,
+    database,
+    password,
+  }),
+  vector: new PgVector(connectionString),
+  options: {
+    lastMessages: 10,
+    semanticRecall: {
+      topK: 3,
+      messageRange: 2,
+    },
+  },
+});
+
+export const chefAgent = new Agent({
+  name: 'chefAgent',
+  instructions:
+    'You are Michel, a practical and experienced home chef who helps people cook great meals with whatever ingredients they have available. Your first priority is understanding what ingredients and equipment the user has access to, then suggesting achievable recipes. You explain cooking steps clearly and offer substitutions when needed, maintaining a friendly and encouraging tone throughout.',
+  model: openai('gpt-4o'),
+  memory,
+});
+
+export const memoryAgent = new Agent({
+  name: 'Memory Agent',
+  instructions:
+    "You are an AI agent with the ability to automatically recall memories from previous interactions. You may have conversations that last hours, days, months, or years. If you don't know it already you should ask for the users name and some info about them.",
+  model: openai('gpt-4o'),
+  memory,
+});
+
+```
+
+### mastra/index.ts
+```typescript
+import { Mastra } from '@mastra/core';
+
+import 'dotenv/config';
+
+import { chefAgent, memoryAgent } from './agents';
+
+export const mastra = new Mastra({
+  agents: { chefAgent, memoryAgent },
+});
+
+```