Nosana x Mastra: インテリジェントAIエージェントの構築

npm create mastra@latest my-agent-project

Where should we create the Mastra files? (default: src/)
│  src/
│
◇  Select a default provider:
│  OpenAI
│
◇  Enter your OpenAI API key?
│  Skip for now
│
◇  Make your IDE into a Mastra expert? (Installs Mastra's MCP server)
│  Skip for now

cd my-agent-project

https://YOUR_NOSANA_URL_ID.node.k8s.prd.nos.ci

# For Nosana Ollama Endpoint with GPT-OSS 20B
OLLAMA_API_URL=https://YOUR_NOSANA_URL_ID.node.k8s.prd.nos.ci/api
MODEL_NAME_AT_ENDPOINT=gpt-oss:20b

I need to configure my Mastra project to use Ollama instead of OpenAI.
Please help me:

1. Update the agent configuration files to use Ollama with the following
   settings:
   - API URL: process.env.OLLAMA_API_URL
   - Model: process.env.MODEL_NAME_AT_ENDPOINT
2. Update any imports and model initialization to use the Ollama provider
   from @ai-sdk/ollama
3. Ensure all agents in the project are configured to use this Ollama setup

pnpm run dev

...
 mastra  0.17.7 ready in XXXX ms

│ Playground: http://localhost:4111/
│ API:        http://localhost:4111/api

// src/mastra/agents/assistant.ts
import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';

export const assistantAgent = new Agent({
  name: 'Personal Assistant',
  instructions: `You are a helpful personal assistant that can:
    - Answer questions about various topics
    - Help with task management
    - Provide recommendations
    
    Always be concise and accurate in your responses.
    Use available tools when needed to accomplish tasks.`,
  model: openai('gpt-4o-mini'),
  tools: {},
});

// src/mastra/tools/index.ts
import { createTool } from '@mastra/core';
import { z } from 'zod';

export const searchTool = createTool({
  id: 'web-search',
  description: 'Search the web for information on a given topic',
  inputSchema: z.object({
    query: z.string().describe('The search query'),
  }),
  outputSchema: z.object({
    results: z.string().describe('Search results summary'),
  }),
  execute: async ({ context }) => {
    const { query } = context;
    const response = await fetch(
      `https://api.example.com/search?q=${encodeURIComponent(query)}`
    );
    const data = await response.json();
    
    return {
      results: data.summary || 'No results found',
    };
  },
});

export const calculatorTool = createTool({
  id: 'calculator',
  description: 'Perform mathematical calculations',
  inputSchema: z.object({
    expression: z.string().describe('Mathematical expression to evaluate'),
  }),
  outputSchema: z.object({
    result: z.number(),
  }),
  execute: async ({ context }) => {
    const { expression } = context;
    try {
      const result = eval(expression);
      return { result: parseFloat(result) };
    } catch (error) {
      throw new Error('Invalid mathematical expression');
    }
  },
});

import { assistantAgent } from './agents/assistant';
import { searchTool, calculatorTool } from './tools';

export const enhancedAgent = new Agent({
  name: 'Enhanced Assistant',
  instructions: assistantAgent.instructions,
  model: openai('gpt-4o-mini'),
  tools: { searchTool, calculatorTool },
});

// src/mastra/workflows/research.ts
import { Step, Workflow, createWorkflow } from '@mastra/core/workflows';
import { z } from 'zod';
import { researchAgent } from '../agents/research';
import { writerAgent } from '../agents/writer';

const researchStep = new Step({
  id: 'research',
  execute: async ({ context }) => {
    const { topic } = context.triggerData;
    
    const result = await researchAgent.generate(
      `Research comprehensive information about: ${topic}`
    );
    
    return { research: result.text };
  },
});

const writeStep = new Step({
  id: 'write',
  execute: async ({ context }) => {
    const research = context.getStepResult('research')?.research;
    
    const result = await writerAgent.generate(
      `Write a detailed article using this research: ${research}`
    );
    
    return { article: result.text };
  },
});

export const researchWorkflow = createWorkflow({
  name: 'research-and-write',
  triggerSchema: z.object({
    topic: z.string(),
  }),
})
  .then(researchStep)
  .then(writeStep)
  .commit();

const result = await researchWorkflow.execute({
  triggerData: { topic: 'Quantum Computing' },
});

console.log(result.results.write.article);

import { Agent } from '@mastra/core/agent';
import { Memory } from '@mastra/memory';

export const memoryAgent = new Agent({
  name: 'Memory-Enabled Assistant',
  instructions: 'You remember past conversations and provide personalized responses.',
  model: openai('gpt-4o-mini'),
  memory: new Memory(),
  tools: {},
});

const response = await memoryAgent.generate(
  'My name is Alex and I work in finance',
  {
    memory: {
      thread: 'user-123',
      resourceid: 'conversation',
    },
  }
);

const followUp = await memoryAgent.generate(
  'What did I say my profession was?',
  {
    memory: {
      thread: 'user-123',
      resourceid: 'conversation',
    },
  }
);

import { createEval } from '@mastra/core';

const accuracyEval = createEval({
  name: 'response-accuracy',
  evaluate: async ({ output, expected }) => {
    const score = calculateSimilarity(output, expected);
    return {
      score,
      passed: score > 0.8,
      metadata: { output, expected },
    };
  },
});