dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
	testImplementation 'org.springframework.boot:spring-boot-starter-data-mongodb-test'
    // 他省略
}

spring.mongodb.uri=mongodb://localhost:27017/demo?directConnection=true

package com.example.demo.models;

import java.time.LocalDateTime;
import org.springframework.data.mongodb.core.mapping.Document;
import lombok.Data;

// ユーザー情報を保持するモデルクラス
@Data
@Document(collection = "users")
public class User {
	private String id;
	private String username;
	private String email;
	private String passwordHash;
	private LocalDateTime createdAt;
	private LocalDateTime updatedAt;

	public User() {
		this.createdAt = LocalDateTime.now();
		this.updatedAt = this.createdAt;
	}

	public User(String username) {
		this.username = username;
		this.createdAt = LocalDateTime.now();
		this.updatedAt = this.createdAt;
	}
}

package com.example.demo.repository;

import java.util.List;
import com.example.demo.models.User;
import org.springframework.data.mongodb.repository.MongoRepository;

public interface UserRepository extends MongoRepository<User, String> {
  public List<User> findByUsername(String username);
}

package com.example.demo;

import com.example.demo.models.User;
import com.example.demo.repository.UserRepository;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping("/hello")
    public String hello() {
        // ユーザーコレクションをクリアしてから新しいユーザーを保存
        userRepository.deleteAll();
        userRepository.save(new User("n-ozawan"));

        // "n-ozawan" というユーザー名でユーザーを検索
        List<User> users = userRepository.findByUsername("n-ozawan");

        // 検索結果を文字列に変換して返す
        return users.stream()
                .map(User::toString)
                .collect(Collectors.joining(", "));
    }
}

[
  {
    _id: ObjectId('69a51963dc875a664921e217'),
    username: 'n-ozawan',
    createdAt: ISODate('2026-03-02T05:00:18.977Z'),
    updatedAt: ISODate('2026-03-02T05:00:18.977Z'),
    _class: 'com.example.demo.models.User'
  }
]

package com.example.demo;

import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.bson.Document;
import org.springframework.data.mongodb.core.query.Query;
import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Query.query;

@RestController
public class Hello2Controller {

    @Autowired
    private MongoTemplate mongoTemplate;

    @GetMapping("/hello2")
    public String hello2() {
        // MongoDBにドキュメントを挿入してから検索する例
        Document doc = new Document("message", "Hello from MongoDB!")
            .append("hoge", new Document("fuga", 123));

        // コレクションを一旦クリアしてから新しいドキュメントを挿入
        mongoTemplate.dropCollection("greetings");
        mongoTemplate.insert(doc, "greetings");

        // "message" フィールドが "Hello from MongoDB!" であるドキュメントを検索
        Query query = query(where("message").is("Hello from MongoDB!"));
        query.fields().include("message").exclude("_id");
        List<Document> documents = mongoTemplate.query(Document.class)
                .inCollection("greetings")
                .matching(query).all();

        // 検索結果を文字列に変換して返す
        return documents.stream()
                .map(Document::toJson)
                .collect(Collectors.joining(", "));
    }
}

sudo apt update && sudo apt install zstd       // zstd のインストール
curl -fsSL https://ollama.com/install.sh | sh  // Ollama のインストール
ollama pull nomic-embed-text                   // ベクトル変換を可能とするモデル(nomic-embed-text)を追加

// vector_demo 内のコレクション全てを削除（一旦クリーンな状態にします）
use vector_demo
db.getCollectionNames().forEach(name => db.getCollection(name).drop())

// データを挿入（この時点ではベクトル情報はありません）
db.items.insertMany([
  { title: "red apple" },
  { title: "green apple" },
  { title: "apple juice" },
  { title: "blue ocean" },
  { title: "deep sea" }
])

echo "red apple" | ollama run nomic-embed-text

mkdir ollama-embed
cd ollama-embed
npm -y init
npm install mongodb

import { MongoClient } from "mongodb";
import { spawnSync} from "child_process";

const uri = "mongodb://localhost/?directConnection=true";
const client = new MongoClient(uri);

// 文章をベクトルに変换する
function getEmbedding(text) {
  const res = spawnSync("ollama", ["run", "nomic-embed-text"], {
    input: String(text),
    encoding: "utf-8",
    timeout: 30_000,
    maxBuffer: 10 * 1024 * 1024,
  });

  if (res.error) throw res.error;
  if (res.status !== 0) throw new Error(res.stderr || "ollama failed");

  return JSON.parse(res.stdout);
}

// 変換したベクトルを各ドキュメントに追加する
async function run() {
  await client.connect();
  const col = client.db("vector_demo").collection("items");

  const cursor = col.find({});
  for await (const doc of cursor) {
    const embedding = getEmbedding(doc.title);
    await col.updateOne(
      { _id: doc._id },
      { $set: { embedding } }
    );
    console.log(`embedded: ${doc.title}`);
  }

  await client.close();
}

run();

node embed.mjs

embedded: red apple
embedded: green apple
embedded: apple juice
embedded: blue ocean
embedded: deep sea

use vector_demo
db.items.find()

[
  {
    _id: ObjectId('6997bbf9b630dc76638de666'),
    title: 'red apple',
    embedding: [
      0.025105005,     0.08147168,    -0.13502309,   0.028353626,
      // ... 764 more items
   ]
  }
  , { /* ... more documents ... */ }
]

db.items.createSearchIndex(
  "vector_index", 
  "vectorSearch", 
  {
    "fields": [
      {
        "type": "vector",        // ベクトル検索を有効化
        "path": "embedding",     // ベクトル検索の対象となるフィールド名
        "numDimensions": 768,    // 次元数
        "similarity": "cosine"   // 距離計算の種類 (この場合はコサイン類似度を選択)
      }
    ]
  }
)

echo "fruits" | ollama run nomic-embed-text > query.json

use vector_demo

// ファイル`query.json`の内容を読み込み
const query = JSON.parse(
  require("fs").readFileSync("query.json")
);

// 検索実行
db.items.aggregate([
  {
    $vectorSearch: {
      index: "vector_index",     // ベクトル検索用インデックスを指定
      path: "embedding",         // ベクトル検索の対象となるフィールド名
      queryVector: query,        // "fruits"のベクトル情報
      numCandidates: 100,        // 候補ベクトルの最大数 (limitの10～20倍程度を指定)
      limit: 5                   // 最大5件出力
    }
  },
  {
    $project: {
      _id: 0,
      title: 1,
      score: { $meta: "vectorSearchScore" }
    }
  }
])

[
  { title: 'green apple', score: 0.8258388042449951 },
  { title: 'apple juice', score: 0.8067097663879395 },
  { title: 'red apple', score: 0.8048827648162842 },
  { title: 'blue ocean', score: 0.7115285396575928 },
  { title: 'deep sea', score: 0.6661980152130127 }
]

db.inventory.insertMany( [
   { prodId: 100, price: 20, quantity: 125 },
   { prodId: 101, price: 10, quantity: 234 },
   { prodId: 102, price: 15, quantity: 432 },
   { prodId: 103, price: 17, quantity: 320 }
] )

db.orders.insertMany( [
   { orderId: 201, custid: 301, prodId: 100, numPurchased: 20 },
   { orderId: 202, custid: 302, prodId: 101, numPurchased: 10 },
   { orderId: 203, custid: 303, prodId: 102, numPurchased: 5 },
   { orderId: 204, custid: 303, prodId: 103, numPurchased: 15 },
   { orderId: 205, custid: 303, prodId: 103, numPurchased: 20 },
   { orderId: 206, custid: 302, prodId: 102, numPurchased: 1 },
   { orderId: 207, custid: 302, prodId: 101, numPurchased: 5 },
   { orderId: 208, custid: 301, prodId: 100, numPurchased: 10 },
   { orderId: 209, custid: 303, prodId: 103, numPurchased: 30 }
] )

db.orders.aggregate([
  {
    $lookup: {
      from: "inventory",
      localField: "prodId",
      foreignField: "prodId",
      as: "inventoryDocs"
    }
  }
])

[
  {
    _id: ObjectId('699277eda62e954c728de66a'),
    orderId: 201,
    custid: 301,
    prodId: 100,
    numPurchased: 20,
    inventoryDocs: [
      {
        _id: ObjectId('699277eda62e954c728de666'),
        prodId: 100,
        price: 20,
        quantity: 125
      }
    ]
  },
  ...(以下省略)
]

db.orders.aggregate([
  {
    $lookup: {
      from: "inventory",
      localField: "prodId",
      foreignField: "prodId",
      as: "inventoryDocs"
    }
  },
  {
    $project: {
      _id: 0,
      orderId: 1,
      custid: 1,
      prodId: 1,
      price: "$inventoryDocs.price"
    }
  },
  { $unwind: "$price" }
])

[
  { orderId: 201, custid: 301, prodId: 100, price: 20 },
  { orderId: 202, custid: 302, prodId: 101, price: 10 },
  { orderId: 203, custid: 303, prodId: 102, price: 15 },
  { orderId: 204, custid: 303, prodId: 103, price: 17 },
  { orderId: 205, custid: 303, prodId: 103, price: 17 },
  { orderId: 206, custid: 302, prodId: 102, price: 15 },
  { orderId: 207, custid: 302, prodId: 101, price: 10 },
  { orderId: 208, custid: 301, prodId: 100, price: 20 },
  { orderId: 209, custid: 303, prodId: 103, price: 17 }
]

db.orders.aggregate([
  { /* $lookupなどで結合 */ },
  { $merge: { into: "ordersWithPrice" } }
])

db.createView( "sales", "orders", [
  {
    $lookup: {
      from: "inventory",
      localField: "prodId",
      foreignField: "prodId",
      as: "inventoryDocs"
    }
  },
  {
    $project: {
      _id: 0,
      prodId: 1,
      orderId: 1,
      numPurchased: 1,
      price: "$inventoryDocs.price"
    }
  },
  { $unwind: "$price" }
] )

db.sales.find()

[
  { orderId: 201, prodId: 100, numPurchased: 20, price: 20 },
  { orderId: 202, prodId: 101, numPurchased: 10, price: 10 },
  { orderId: 203, prodId: 102, numPurchased: 5, price: 15 },
  { orderId: 204, prodId: 103, numPurchased: 15, price: 17 },
  { orderId: 205, prodId: 103, numPurchased: 20, price: 17 },
  { orderId: 206, prodId: 102, numPurchased: 1, price: 15 },
  { orderId: 207, prodId: 101, numPurchased: 5, price: 10 },
  { orderId: 208, prodId: 100, numPurchased: 10, price: 20 },
  { orderId: 209, prodId: 103, numPurchased: 30, price: 17 }
]

show dbs

use hoge

use hoge
db.dropDatabase()

show collections

db.hoge.drop()

db.collection.find()

db.collection.find({orderId: 204})                // orderIdが204のドキュメントを検索
db.collection.find({orderId: 204, prodId: 103})   // orderIdが204、かつ、prodIdが103のドキュメントを検索
db.collection.find({orderId: {$gte: 200}})        // orderIdが200以上のドキュメントを検索
db.collection.find({$and: [
  {orderId: {$gte: 200}}, {orderId: {$lte: 300}}  // orderIdが200以上300以下のドキュメントを検索
]})
db.collection.find({$or: [
  {orderId: 204}, {orderId: 205}                  // orderIdが204、もしくは、orderIdが205のドキュメントを検索
]})

db.collection.find({}, {_id: 0, orderId: 1})  // orderIdのみを表示する

db.collection.insertOne(
  {orderId: 317, prodId: 102}   // 1件挿入
)
db.collection.insertMany([
  {orderId: 317, prodId: 102},  // 複数件挿入
  {orderId: 317, prodId: 102}
])

db.collection.updateOne({orderId: 209}, {$set: {prodId:105}})   // 1件更新
db.collection.updateMany({orderId: 209}, {$set: {prodId:105}})  // 複数件更新

db.collection.updateOne({orderId: 209}, {$set: {prodId:105}})          // prodIdを105に変更
db.collection.updateOne({orderId: 209}, {$unset: {prodId:1}})          // prodIdを削除
db.collection.updateOne({orderId: 209}, {$rename: {prodId:"hogeId"}})  // prodIdをhogeIdに名前変更

db.collection.deleteOne({orderId: 209})    // 1件削除
db.collection.deleteMany({orderId: 209})   // 複数件削除

["hoge","foo","bar"].forEach(name => db.getCollection(name).insertOne({x: 1}))

db.getCollectionNames().forEach(name => db.getCollection(name).drop())

{
  "_id": {"$oid":"5d505646cf6d4fe581014ab2"},                  // ObjectID型
  "createAt": {"$date":"2019-08-11 T 17:54:14.692 Z"},         // 日付型
  "bin": {"$binary": {"base64": "AQIDBA==", "subType": "00"}}, // バイナリ型
  "uuid": {"$uuid":"3b241101-e2bb-4255-8caf-4136c566a962"},    // UUID表現 (厳密にはバイナリ型)
  "int32": {"$numberInt":"10"},                                // 32ビット型Integer、単に{"int32": 10}でもOK
  "int64": {"$numberInt":"50"}                                 // 64ビット型Integer、単に{"int64": 50}でもOK
}

AtlasLocalDev myDeployment [direct: primary] test> db.coll.find()

[
  { _id: ObjectId('6980462972ba91833b8de66a'), name: 'n-ozawan' },
  { _id: ObjectId('6980462972ba91833b8de66b'), title: 'MongoDBの基礎知識' },
  {
    _id: ObjectId('6980465e72ba91833b8de66c'),
    createAt: ISODate('2026-02-02T06:45:24.840Z')
  }
]

db.createCollection("students", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         title: "Student Object Validation",
         required: [ "address", "major", "name", "year" ],
         properties: {
            name: {
               bsonType: "string",
               description: "'name' must be a string and is required"
            },
            year: {
               bsonType: "int",
               minimum: 2017,
               maximum: 3017,
               description: "'year' must be an integer in [ 2017, 3017 ] and is required"
            },
            gpa: {
               bsonType: [ "double" ],
               description: "'gpa' must be a double if the field exists"
            }
         }
      }
   }
} )

# aptで使用される公開鍵をインポートする
curl -fsSL https://pgp.mongodb.com/server-7.0.asc | sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg --dearmor

# Mongo DB のエディションのリストファイルを作成する
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

# Atras CLI をインストールする
sudo apt update && sudo apt install -y mongodb-atlas

atlas --version

sudo atlas deployments setup myDeployment --type local --mdbVersion 8.0 --port 27017 --connectWith skip

Deployment created!
Connection string: "mongodb://localhost:27017/?directConnection=true"

sudo atlas deployments connect myDeployment --connectWith mongosh

AtlasLocalDev myDeployment [direct: primary] test> db.users.insertOne({name: "n-ozawan"})

{
  acknowledged: true,
  insertedId: ObjectId('6976cf8f6327271a368de667')
}

AtlasLocalDev myDeployment [direct: primary] test> db.users.find()

[
  { _id: ObjectId('6976cf8f6327271a368de667'), name: 'n-ozawan' }
]