Mastra で遊ぶ

cd ~/workspace
pnpm create mastra@latest my-mastra-app

┌  Mastra Create
│
◇  Project created
│
◇  pnpm dependencies installed
│
◇  mastra installed
│
◇  Dependencies installed
│
◇  .gitignore added
│
└  Project created successfully


┌  Mastra Init
│
◇  Where should we create the Mastra files? (default: src/)
│  src/
│
◇  Choose components to install:
│  Agents
│
◇  Add tools?
│  Yes
│
◇  Select default provider:
│  OpenAI
│
◇  Enter your openai API key?
│  Skip for now
│
◇  Add example
│  Yes
│
◇  Make your AI IDE into a Mastra expert? (installs Mastra docs MCP server)
│  Skip for now
│
◇  
│
◇   ─────────────────────────────────────────────────────────╮
│                                                            │
│                                                            │
│        Mastra initialized successfully!                    │
│                                                            │
│        Add your OPENAI_API_KEY as an environment variable  │
│        in your .env.development file                       │
│                                                            │
│                                                            │
├────────────────────────────────────────────────────────────╯
│
└  
   To start your project:

    cd my-mastra-app
    npm run dev

pnpm add --save-dev --save-exact @biomejs/biome
pnpm biome init

pnpm add @openrouter/ai-sdk-provider

import { createOpenAI } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { LibSQLStore } from "@mastra/libsql";
import { Memory } from "@mastra/memory";
import { weatherTool } from "../tools";

const openrouter = createOpenAI({
  baseURL: "https://openrouter.ai/api/v1",
  apiKey: process.env.OPENROUTER_API_KEY,
});

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
      - 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: openrouter("deepseek/deepseek-chat-v3-0324:free"),
  tools: { weatherTool },
  memory: new Memory({
    storage: new LibSQLStore({
      url: "file:../mastra.db", // path is relative to the .mastra/output directory
    }),
    options: {
      lastMessages: 10,
      semanticRecall: false,
      threads: {
        generateTitle: false,
      },
    },
  }),
});

pnpm dev

touch test.ts
pnpm i ai
pnpm i -D tsx

import { createOpenAI } from "@ai-sdk/openai";
import { streamText } from "ai";

async function main() {
  const openrouter = createOpenAI({
    baseURL: "https://openrouter.ai/api/v1",
    apiKey: process.env.OPENROUTER_API_KEY,
  });

  const { textStream, response } = streamText({
    model: openrouter.chat("deepseek/deepseek-chat-v3-0324:free"),
    prompt: "OpenRouter とは何ですか？",
  });

  for await (const text of textStream) {
    process.stdout.write(text);
  }
}

main().catch((err) => console.error(err));

pnpm exec tsx --env-file .env.development test.ts

**OpenRouter**は、複数のAIモデル（GPT-4、Claude、Gemini、Mistralなど）を単一のAPIで利用できる**AIモデル統合プラットフォーム**です。開発者や企業がさまざまな最先端のAIを簡単に比較・切り替えできるように設計されています。

### 主な特徴
1. **マルチモデル対応**  
   OpenAI、Anthropic、Google DeepMind、Mistralなどの主要モデルを統合。モデルごとに性能や価格を比較可能。

2. **統一API**  
   異なるプロバイダーのモデルを、OpenRouterの共通APIで呼び出せます。コードを書き換える必要がありません。

3. **コスト最適化**  
   モデルごとの価格（トークン単価）が可視化され、安価なモデルを選択可能。自動ルーティングでコスト削減も。

4. **追加機能**  
   - チャット履歴の保存
   - 使用量分析ダッシュボード
   - ユーザー認証の簡素化（OAuth対応）

### 主な用途
- 複数AIの性能比較
- ベンダーロックインの回避
- コスト効率の良いAIアプリ開発

### 料金モデル
各モデルの提供元が設定した価格に従い、トークン単位で課金されます。無料枠のあるモデル（例：Mistral 7B）も利用可能。

OpenRouterは、特定のプロバイダーに依存せず柔軟にAIを活用したい開発者にとって有用なツールです。詳細は[公式サイト](https://openrouter.ai/)をご覧ください。

import { createOpenAI } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { LibSQLStore } from "@mastra/libsql";
import { Memory } from "@mastra/memory";
import { weatherTool } from "../tools";

// const openrouter = createOpenAI({
//   baseURL: "https://openrouter.ai/api/v1",
//   apiKey: process.env.OPENROUTER_API_KEY,
// });

const deepseek = createOpenAI({
  baseURL: "https://api.deepseek.com/v1",
  apiKey: process.env.DEEPSEEK_API_KEY,
});

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
      - 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: openrouter("deepseek/deepseek-chat-v3-0324:free"),
  model: deepseek("deepseek-chat"),
  tools: { weatherTool },
  memory: new Memory({
    storage: new LibSQLStore({
      url: "file:../mastra.db", // path is relative to the .mastra/output directory
    }),
    options: {
      lastMessages: 10,
      semanticRecall: false,
      threads: {
        generateTitle: false,
      },
    },
  }),
});

curl -X POST http://localhost:4111/api/agents/weatherAgent/generate \
  -H "Content-Type: application/json" \
  -d '{"messages": ["ロンドンの天気を教えてください"]}'

touch src/mastra/tools/add.ts

import { createTool } from "@mastra/core";
import { z } from "zod";

export const addTool = createTool({
  id: "add",
  description: "Add two numbers together",
  inputSchema: z.object({
    a: z.number().describe("The first number"),
    b: z.number().describe("The second number"),
  }),
  outputSchema: z.object({
    sum: z.number().describe("The sum of the two numbers"),
  }),
  execute: async ({ context }) => {
    return {
      sum: context.a + context.b,
    };
  },
});

touch src/mastra/agents/add.ts

import { createOpenAI } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { addTool } from "../tools/add";

const deepseek = createOpenAI({
  baseURL: "https://api.deepseek.com/v1",
  apiKey: process.env.DEEPSEEK_API_KEY,
});

export const addAgent = new Agent({
  name: "Add Agent",
  instructions: `
    You are a helpful assistant that adds two numbers together.
  `,
  model: deepseek("deepseek-chat"),
  tools: {
    addTool,
  },
});

import { createLogger } from "@mastra/core/logger";
import { Mastra } from "@mastra/core/mastra";
import { LibSQLStore } from "@mastra/libsql";

import { weatherAgent } from "./agents";
import { addAgent } from "./agents/add";

export const mastra = new Mastra({
  agents: { weatherAgent, addAgent },
  storage: new LibSQLStore({
    // stores telemetry, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
    url: ":memory:",
  }),
  logger: createLogger({
    name: "Mastra",
    level: "info",
  }),
});

pnpm dev

npx -y @mastra/mcp-docs-server@latest

Mastra のチュートリアルが終わって自作のツールとエージェントを追加する練習が終わりました。次は何をすれば良いでしょうか？

import { createOpenAI } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { Memory } from "@mastra/memory";
import { addTool } from "../tools/add";

const deepseek = createOpenAI({
  baseURL: "https://api.deepseek.com/v1",
  apiKey: process.env.DEEPSEEK_API_KEY,
});

export const addAgent = new Agent({
  name: "Add Agent",
  instructions: `
    You are a helpful assistant that adds two numbers together.
  `,
  model: deepseek("deepseek-chat"),
  tools: {
    addTool,
  },
  memory: new Memory(),
});

!MEMORY DEPRECATION WARNING!
Warning 1:

Default storage is deprecated in Mastra Memory.
You're using it as an implicit default by not setting a storage adapter.

In the May 20th breaking change the default store will be removed.

Instead of this:
export const agent = new Agent({
  memory: new Memory({
    // your config
  })
})

Do this:
import { LibSQLStore } from '@mastra/libsql';

export const agent = new Agent({
  memory: new Memory({
    // your config
    storage: new LibSQLStore({
      url: 'file:../mastra.db' // relative path from bundled .mastra/output dir
    })
  })
})

Additionally, in the breaking release, Memory will inherit storage from the Mastra instance.
If you plan on using that feature you can prepare by setting the same storage instance on Mastra and Memory.

Ex:
// mastra/storage.ts
export const storage = new LibSQLStore({
  url: 'file:../mastra.db'
})

// mastra/index.ts
import { storage } from "./storage"
export const mastra = new Mastra({
  // your config
  storage
})

// mastra/agents/index.ts
import { storage } from "../storage"
export const yourAgent = new Agent({
  // your config
  storage
})


Warning 2:

Default vector storage is deprecated in Mastra Memory.
You're using it as an implicit default by not setting a vector store.

In the May 20th breaking change the default vector store will be removed.

Instead of this:
export const agent = new Agent({
  memory: new Memory({
    options: { semanticRecall: true }
  })
})

Do this:
import { LibSQLVector } from '@mastra/libsql';

export const agent = new Agent({
  memory: new Memory({
    options: { semanticRecall: true },
    vector: new LibSQLVector({
      connectionUrl: 'file:../mastra.db' // relative path from bundled .mastra/output dir
    })
  })
})


Warning 3:

The default embedder (FastEmbed) is deprecated in Mastra Memory.
You're using it as an implicit default by not configuring an embedder.

On May 20th there will be a breaking change and the default embedder will be removed from @mastra/core.

To continue using FastEmbed, install the dedicated package:
pnpm add @mastra/fastembed

Then configure it in your Memory setup:

import { fastembed } from '@mastra/fastembed';

export const agent = new Agent({
  memory: new Memory({
    embedder: fastembed, // Configure the embedder
    // your other config
  })
})

Alternatively, you can use a different embedder, like OpenAI:
import { openai } from '@ai-sdk/openai';

export const agent = new Agent({
  memory: new Memory({
    embedder: openai.embedding('text-embedding-3-small'),
    // your other config
  })
})

--> This breaking change will be released on May 20th <--


Warning 4:

Your Mastra memory instance has the
following implicit default options:

new Memory({
  options: {
    lastMessages: 40,
    semanticRecall: {
      topK: 2,
      messageRange: {
        before: 2,
        after: 2
      }
    },
    threads: {
      generateTitle: true
    }
  }
})

In the next release these implicit defaults
will be changed to the following default settings:

new Memory({
  options: {
    lastMessages: 10,
    semanticRecall: false,
    threads: {
      generateTitle: false
    }
  }
})

To keep your defaults as they are, add
them directly into your Memory configuration,
otherwise please add the new settings to
your memory config to prepare for the change.

--> This breaking change will be released on May 20th <--

!END MEMORY DEPRECATION WARNING!

touch src/use-agent.ts
pnpm i -D tsx

import { addAgent } from "./mastra/agents/add";

async function main() {
  const response = await addAgent.generate(["add 1 and 2"]);
  console.log(response.text);
}

main().catch((err) => {
  console.error(err);
});

pnpm tsx --env-file .env.development src/use-agent.ts

The sum of 1 and 2 is 3.

touch src/use-structured-output.ts

import { z } from "zod";
import { addAgent } from "./mastra/agents/add";

async function main() {
  const schema = z.object({
    name: z.string().describe("氏名"),
    email: z.string().describe("住所"),
  });

  const response = await addAgent.generate(
    [
      `
        下記の文章から必要事項を抜き出して、JSON形式で出力してください。

        氏名: 山田 太郎
        住所: 東京都新宿区西新宿2-8-1
        誕生日: 1990年1月1日
        電話番号: 03-1234-5678
        メールアドレス: taro.yamada@example.com
      `,
    ],
    {
      output: schema,
    },
  );

  console.log(response.object);
}

main().catch((err) => {
  console.error(err);
});

pnpm tsx --env-file .env.development src/use-structured-output.ts

{ name: '山田 太郎', email: 'taro.yamada@example.com' }

touch src/use-memory.ts

import { addAgent } from "./mastra/agents/add";

async function main() {
  const firstResponse = await addAgent.stream(
    "私が好きな色が青色です、覚えておいてください。",
    {
      resourceId: "user_alice",
      threadId: "thread_123",
    },
  );

  for await (const chunk of firstResponse.textStream) {
    process.stdout.write(chunk);
  }

  const secondResponse = await addAgent.stream(
    "私が好きな色を覚えていますか？",
    {
      resourceId: "user_alice",
      threadId: "thread_123",
    },
  );

  for await (const chunk of secondResponse.textStream) {
    process.stdout.write(chunk);
  }
}

main().catch((err) => {
  console.error(err);
});

pnpm tsx --env-file .env.development src/use-memory.ts

わかりました！あなたの好きな色は青色ですね。覚えておきます。何か他に質問やお手伝いできることがあれば教えてください！はい、覚えていますよ！あなたの好きな色は**青色**です。何か青色に関連することをお手伝いしましょうか？

touch src/mastra/agents/mcp.ts
pnpm add @mastra/mcp@latest

import { createOpenAI } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { MCPClient } from "@mastra/mcp";

const mcp = new MCPClient({
  servers: {
    puppeteer: {
      command: "npx",
      args: ["-y", "@modelcontextprotocol/server-puppeteer"],
      env: {
        PUPPETEER_LAUNCH_OPTIONS: JSON.stringify({
          headless: false,
          executablePath:
            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
          args: [],
        }),
      },
    },
  },
});

const deepseek = createOpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  baseURL: "https://api.deepseek.com/v1",
});

export const mcpAgent = new Agent({
  name: "Agent with MCP Tools",
  instructions:
    "あなたは MCP サーバーから提供されるツールを使うことができます。",
  model: deepseek("deepseek-chat"),
  tools: await mcp.getTools(),
});

import { createLogger } from "@mastra/core/logger";
import { Mastra } from "@mastra/core/mastra";
import { LibSQLStore } from "@mastra/libsql";

import { weatherAgent } from "./agents";
import { addAgent } from "./agents/add";
import { mcpAgent } from "./agents/mcp";

export const mastra = new Mastra({
  agents: { weatherAgent, addAgent, mcpAgent },
  storage: new LibSQLStore({
    // stores telemetry, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
    url: ":memory:",
  }),
  logger: createLogger({
    name: "Mastra",
    level: "info",
  }),
});

const newMemoryDefaultOptions = {
  lastMessages: 10,
  semanticRecall: false,
  threads: {
    generateTitle: false,
  },
  workingMemory: {
    // new
    use: 'tool-call',
    // stays the same
    enabled: false,
    template: `
# User Information
- **First Name**: 
- **Last Name**: 
- **Location**: 
- **Occupation**: 
- **Interests**: 
- **Goals**: 
- **Events**: 
- **Facts**: 
- **Projects**: 
`,
  },
} satisfies MemoryConfig;

LangChain にワークフローの機能があると思いますが、
これは LLM を使用したアプリではワークフローが必要な場面が多いからでしょうか？

rm -rf my-mastra-app
pnpm create mastra@latest \
  --components agents,tools \
  --llm openai \
  --example \
  --project-name my-mastra-app

OPENAI_API_KEY="sk-xxxx"

export PG_CONFIG="/opt/homebrew/opt/postgresql@17/bin/pg_config"
brew install pgvector
createdb vector_test
psql vector_test

CREATE EXTENSION VECTOR;

brew install postgresql@17

==> postgresql@17
This formula has created a default database cluster with:
  initdb --locale=C -E UTF-8 /opt/homebrew/var/postgresql@17

When uninstalling, some dead symlinks are left behind so you may want to run:
  brew cleanup --prune-prefix

postgresql@17 is keg-only, which means it was not symlinked into /opt/homebrew,
because this is an alternate version of another formula.

If you need to have postgresql@17 first in your PATH, run:
  echo 'export PATH="/opt/homebrew/opt/postgresql@17/bin:$PATH"' >> ~/.zshrc

For compilers to find postgresql@17 you may need to set:
  export LDFLAGS="-L/opt/homebrew/opt/postgresql@17/lib"
  export CPPFLAGS="-I/opt/homebrew/opt/postgresql@17/include"

To start postgresql@17 now and restart at login:
  brew services start postgresql@17
Or, if you don't want/need a background service you can just run:
  LC_ALL="C" /opt/homebrew/opt/postgresql@17/bin/postgres -D /opt/homebrew/var/postgresql@17

brew services stop postgresql@13
brew services start postgresql@17
brew services list

Name          Status  User     File
cloudflared   none             
postgresql@13 none    root     
postgresql@17 started susukida ~/Library/LaunchAgents/homebrew.mxcl.postgresql@17.plist

# export PATH="/opt/homebrew/opt/postgresql@13/bin:$PATH
export PATH="/opt/homebrew/opt/postgresql@17/bin:$PATH"

which initdb

export PG_CONFIG="/opt/homebrew/opt/postgresql@17/bin/pg_config"
brew install pgvector
createdb vector_test
psql vector_test

CREATE EXTENSION VECTOR;

touch src/embed.ts
pnpm i @mastra/rag @mastra/pg ai

import { openai } from "@ai-sdk/openai";
import { PgVector } from "@mastra/pg";
import { MDocument } from "@mastra/rag";
import { embedMany } from "ai";
import z from "zod";

async function main() {
  const doc = MDocument.fromText("私の名前は薄田達哉です。");
  const chunks = await doc.chunk({
    strategy: "recursive",
    size: 512,
    overlap: 50,
  });

  const { embeddings } = await embedMany({
    values: chunks.map((chunk) => chunk.text),
    model: openai.embedding("text-embedding-3-small"),
  });

  const envSchema = z.object({
    POSTGRES_CONNECTION_STRING: z.string(),
  });

  const env = envSchema.parse(process.env);
  const pgVector = new PgVector({
    connectionString: env.POSTGRES_CONNECTION_STRING,
  });

  await pgVector.upsert({
    indexName: "embeddings",
    vectors: embeddings,
  });
}

main().catch((err) => console.error(err));

createuser -P mastra
createdb mastra --owner mastra
pnpm i -D tsx
touch src/create-index.ts
psql -U susukida mastra

CREATE EXTENSION VECTOR;

POSTGRES_CONNECTION_STRING="postgresql://mastra:mastra@localhost:5432/mastra"

import { PgVector } from "@mastra/pg";
import z from "zod";

async function main() {
  const envSchema = z.object({
    POSTGRES_CONNECTION_STRING: z.string(),
  });

  const env = envSchema.parse(process.env);
  const pgVector = new PgVector({
    connectionString: env.POSTGRES_CONNECTION_STRING,
  });

  await pgVector.createIndex({
    indexName: "embeddings",
    dimension: 1536,
  });

  await pgVector.disconnect();
}

main().catch((err) => console.error(err));

pnpm tsx --env-file .env src/create-index.ts

psql -U mastra mastra

\dt

             リレーション一覧
 スキーマ |    名前    |  タイプ  | 所有者 
----------+------------+----------+--------
 public   | embeddings | テーブル | mastra

pg_dump -U mastra mastra -s -t embeddings

CREATE TABLE public.embeddings (
    id integer NOT NULL,
    vector_id text NOT NULL,
    embedding public.vector(1536),
    metadata jsonb DEFAULT '{}'::jsonb
);

pnpm tsx --env-file .env src/embed.ts

psql -U mastra mastra

SELECT id, vector_id, metadata FROM embeddings;

 id |              vector_id               | metadata 
----+--------------------------------------+----------
  1 | 19acab0b-6e58-4d3b-b1bb-4c38f181f857 | {}
(1 行)

touch src/query.ts

import { openai } from "@ai-sdk/openai";
import { PgVector } from "@mastra/pg";
import { embed } from "ai";
import z from "zod";

async function main() {
  const { embedding } = await embed({
    value: "私の名前は何ですか？",
    model: openai.embedding("text-embedding-3-small"),
  });

  const envSchema = z.object({
    POSTGRES_CONNECTION_STRING: z.string(),
  });

  const env = envSchema.parse(process.env);
  const pgVector = new PgVector({
    connectionString: env.POSTGRES_CONNECTION_STRING,
  });

  const results = await pgVector.query({
    indexName: "embeddings",
    queryVector: embedding,
    topK: 3,
  });

  console.log(results);
}

main().catch((err) => console.error(err));

pnpm tsx --env-file .env src/query.ts

[
  {
    id: '19acab0b-6e58-4d3b-b1bb-4c38f181f857',
    score: 0.5995549796950864,
    metadata: {}
  }
]

pnpm tsx --env-file .env src/embed.ts

select
	(SELECT embedding FROM embeddings where id = 1) =
	(SELECT embedding FROM embeddings where id = 2);

import { openai } from "@ai-sdk/openai";
import { PgVector } from "@mastra/pg";
import { MDocument } from "@mastra/rag";
import { embedMany } from "ai";
import z from "zod";

async function main() {
  const doc = MDocument.fromText("私の名前は薄田達哉です。");
  const chunks = await doc.chunk({
    strategy: "recursive",
    size: 512,
    overlap: 50,
  });

  const { embeddings } = await embedMany({
    values: chunks.map((chunk) => chunk.text),
    model: openai.embedding("text-embedding-3-small"),
  });

  const envSchema = z.object({
    POSTGRES_CONNECTION_STRING: z.string(),
  });

  const env = envSchema.parse(process.env);
  const pgVector = new PgVector({
    connectionString: env.POSTGRES_CONNECTION_STRING,
  });

  await pgVector.upsert({
    indexName: "embeddings",
    vectors: embeddings,
    metadata: chunks.map((chunk) => ({
      text: chunk.text,
    })),
  });
}

main().catch((err) => console.error(err));

touch src/mastra/agents/rag-agent.ts

import { openai } from "@ai-sdk/openai";
import { Agent } from "@mastra/core";
import { PGVECTOR_PROMPT } from "@mastra/pg";
import { createVectorQueryTool } from "@mastra/rag";

const vectorQueryTool = createVectorQueryTool({
  vectorStoreName: "pgVector",
  indexName: "embeddings",
  model: openai.embedding("text-embedding-3-small"),
});

export const ragAgent = new Agent({
  name: "RAG Agent",
  instructions: `
    Process queries using the provided context. Structure responses to be concise and relevant.
    ${PGVECTOR_PROMPT}
  `,
  model: openai("gpt-4o-mini"),
  tools: { vectorQueryTool },
});

import { Mastra } from "@mastra/core/mastra";
import { LibSQLStore } from "@mastra/libsql";
import { PinoLogger } from "@mastra/loggers";

import { PgVector } from "@mastra/pg";
import z from "zod";
import { ragAgent } from "./agents/rag-agent";
import { weatherAgent } from "./agents/weather-agent";

const envSchema = z.object({
  POSTGRES_CONNECTION_STRING: z.string(),
});

const env = envSchema.parse(process.env);
const pgVector = new PgVector({
  connectionString: env.POSTGRES_CONNECTION_STRING,
});

export const mastra = new Mastra({
  vectors: { pgVector },
  agents: { weatherAgent, ragAgent },
  storage: new LibSQLStore({
    url: ":memory:",
  }),
  logger: new PinoLogger({
    name: "Mastra",
    level: "info",
  }),
});

pnpm dev

{
  "queryText": "私の名前",
  "topK": 10
}

{
  "relevantContext": [
    {},
    {},
    {
      "id": "b3af08ab-cb3e-4b7b-93b0-b37937aad078",
      "text": "私の名前は薄田達哉です。"
    },
    {
      "id": "c47f7017-0b63-4338-a23c-f2ebfd20d196",
      "text": "私の名前は薄田達哉です。"
    }
  ],
  "sources": [
    {
      "id": "19acab0b-6e58-4d3b-b1bb-4c38f181f857",
      "vector": [],
      "score": 0.6105680911276717,
      "metadata": {},
      "document": ""
    },
    {
      "id": "ea558718-9010-49c5-97d2-11209feab57f",
      "vector": [],
      "score": 0.6105680911276717,
      "metadata": {},
      "document": ""
    },
    {
      "id": "d7d4ed1d-6fc1-4994-bdbe-ba9399cfae3e",
      "vector": [],
      "score": 0.6105680911276717,
      "metadata": {
        "id": "b3af08ab-cb3e-4b7b-93b0-b37937aad078",
        "text": "私の名前は薄田達哉です。"
      },
      "document": ""
    },
    {
      "id": "afd1e19e-ee12-4079-9125-42f361a56d6d",
      "vector": [],
      "score": 0.6105379957922961,
      "metadata": {
        "id": "c47f7017-0b63-4338-a23c-f2ebfd20d196",
        "text": "私の名前は薄田達哉です。"
      },
      "document": ""
    }
  ]
}