Atlas Vector Search による検索拡張生成（RAG）

環境を設定します。

1. Go プロジェクトを初期化します。

   ターミナルで次のコマンドを実行して、 rag-mongodbという名前の新しいディレクトリを作成し、プロジェクトを初期化します。

   mkdir rag-mongodb
   cd rag-mongodb
   go mod init rag-mongodb

2. 依存関係をインストールしてインポートします。

   次のコマンドを実行します。

   go get github.com/joho/godotenv
   go get go.mongodb.org/mongo-driver/mongo
   go get github.com/tmc/langchaingo/llms
   go get github.com/tmc/langchaingo/documentloaders
   go get github.com/tmc/langchaingo/embeddings/huggingface
   go get github.com/tmc/langchaingo/llms/huggingface
   go get github.com/tmc/langchaingo/prompts

3. .envファイルを作成します。

   プロジェクトで、 Atlas 接続文字列と Hugeface アクセス トークンを保存するための .env ファイルを作成します。

   .env

   HUGGINGFACEHUB_API_TOKEN = "<access-token>"
   ATLAS_CONNECTION_STRING = "<connection-string>"

<access-token> プレースホルダー値を 1 つのドキュメント アクセス トークンに置き換えます。

<connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

接続stringには、次の形式を使用する必要があります。

mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net

ベクトル埋め込みを生成する関数を作成します。

このセクションでは、次の関数を作成します。

• Hugging Face のモデル ハブから、mxbai-embed-large-v1 埋め込みモデルを読み込みます。

• 入力データからベクトル埋め込みを作成します。

1. 次のコマンドを実行して、埋め込みの作成に再利用できるものを含め、共通の機能を格納するディレクトリを作成します。

   mkdir common && cd common

2. common ディレクトリに get-embeddings.go というファイルを作成し、次のコードをそのファイルに貼り付けます。

   get-embeddings.go

   package common
   import (
   	"context"
   	"log"
   	"github.com/tmc/langchaingo/embeddings/huggingface"
   )
   func GetEmbeddings(documents []string) [][]float32 {
   	hf, err := huggingface.NewHuggingface(
   		huggingface.WithModel("mixedbread-ai/mxbai-embed-large-v1"),
   		huggingface.WithTask("feature-extraction"))
   	if err != nil {
   		log.Fatalf("failed to connect to Hugging Face: %v", err)
   	}
   	embs, err := hf.EmbedDocuments(context.Background(), documents)
   	if err != nil {
   		log.Fatalf("failed to generate embeddings: %v", err)
   	}
   	return embs
   }

Atlas にデータを取り込みます。

このセクションでは、LLM がアクセスできないサンプルデータを Atlasに取り込みます。以下のコードでは、LangChain 用の Go ライブラリと Go ドライバを使って、次の処理を実行します。

• MongoDB 収益レポートを含む HTML ファイルを作成します。

• データをチャンクに分割し、チャンク サイズ（文字数）とチャンクの重複（連続するチャンク間で重複する文字数）を指定します。

• 定義したGetEmbeddings関数を使用して、チャンク データからベクトル埋め込みを作成します。

• これらの埋め込みを、Atlas クラスターのrag_db.testコレクション内のチャンク データと一緒に保存します。

1. rag-mongodb プロジェクト ディレクトリのルートに移動します。

2. プロジェクトに ingest-data.go というファイルを作成し、次のコードをそのファイルに貼り付けます。

   ingest-data.go

   package main
   import (
   	"context"
   	"fmt"
   	"io"
   	"log"
   	"net/http"
   	"os"
   	"rag-mongodb/common" // Module that contains the embedding function
   	"github.com/joho/godotenv"
   	"github.com/tmc/langchaingo/documentloaders"
   	"github.com/tmc/langchaingo/textsplitter"
   	"go.mongodb.org/mongo-driver/mongo"
   	"go.mongodb.org/mongo-driver/mongo/options"
   )
   type DocumentToInsert struct {
   	PageContent string    `bson:"pageContent"`
   	Embedding   []float32 `bson:"embedding"`
   }
   func downloadReport(filename string) {
   	_, err := os.Stat(filename)
   	if err == nil {
   		return
   	}
   	url := "https://investors.mongodb.com/node/12236"
   	fmt.Println("Downloading ", url, " to ", filename)
   	resp, err := http.Get(url)
   	if err != nil {
   		log.Fatalf("failed to connect to download the report: %v", err)
   	}
   	defer func() { _ = resp.Body.Close() }()
   	f, err := os.Create(filename)
   	if err != nil {
   		return
   	}
   	defer func() { _ = f.Close() }()
   	_, err = io.Copy(f, resp.Body)
   	if err != nil {
   		log.Fatalf("failed to copy the report: %v", err)
   	}
   }
   func main() {
   	ctx := context.Background()
   	filename := "investor-report.html"
   	downloadReport(filename)
   	f, err := os.Open(filename)
   	if err != nil {
   		defer func() { _ = f.Close() }()
   		log.Fatalf("failed to open the report: %v", err)
   	}
   	defer func() { _ = f.Close() }()
   	html := documentloaders.NewHTML(f)
   	split := textsplitter.NewRecursiveCharacter()
   	split.ChunkSize = 400
   	split.ChunkOverlap = 20
   	docs, err := html.LoadAndSplit(context.Background(), split)
   	if err != nil {
   		log.Fatalf("failed to chunk the HTML into documents: %v", err)
   	}
   	fmt.Printf("Successfully chunked the HTML into %v documents.\n", len(docs))
   	if err := godotenv.Load(); err != nil {
   		log.Fatal("no .env file found")
   	}
   	// Connect to your Atlas cluster
   	uri := os.Getenv("ATLAS_CONNECTION_STRING")
   	if uri == "" {
   		log.Fatal("set your 'ATLAS_CONNECTION_STRING' environment variable.")
   	}
   	clientOptions := options.Client().ApplyURI(uri)
   	client, err := mongo.Connect(ctx, clientOptions)
   	if err != nil {
   		log.Fatalf("failed to connect to the server: %v", err)
   	}
   	defer func() { _ = client.Disconnect(ctx) }()
   	// Set the namespace
   	coll := client.Database("rag_db").Collection("test")
   	fmt.Println("Generating embeddings.")
   	var pageContents []string
   	for i := range docs {
   		pageContents = append(pageContents, docs[i].PageContent)
   	}
   	embeddings := common.GetEmbeddings(pageContents)
   	docsToInsert := make([]interface{}, len(embeddings))
   	for i := range embeddings {
   		docsToInsert[i] = DocumentToInsert{
   			PageContent: pageContents[i],
   			Embedding:   embeddings[i],
   		}
   	}
   	result, err := coll.InsertMany(ctx, docsToInsert)
   	if err != nil {
   		log.Fatalf("failed to insert documents: %v", err)
   	}
   	fmt.Printf("Successfully inserted %v documents into Atlas\n", len(result.InsertedIDs))
   }

3. 次のコマンドを実行して、コードを実行します。

   go run ingest-data.go

   出力を表示

   Successfully chunked the HTML into 163 documents.
   Generating embeddings.
   Successfully inserted document with id: &{ObjectID("66faffcd60da3f6d4f990fa4")}
   Successfully inserted document with id: &{ObjectID("66faffce60da3f6d4f990fa5")}
   ...

Atlas Vector Search を使用してドキュメントを検索します。

このセクションでは、Atlas Vector Search を設定してベクトルデータベースからドキュメントを検索します。 次の手順を実行します。

1. ベクトル埋め込みに Atlas Vector Search インデックスを作成します。

   rag-vector-index.goという名前の新しいファイルを作成し、次のコードを貼り付けます。 このコードは Atlas クラスターに接続し、 rag_db.testコレクションにvectorSearchタイプのインデックスを作成します。

   rag-vector-index.go

   package main
   import (
   	"context"
   	"log"
   	"os"
   	"time"
   	"go.mongodb.org/mongo-driver/bson"
   	"github.com/joho/godotenv"
   	"go.mongodb.org/mongo-driver/mongo"
   	"go.mongodb.org/mongo-driver/mongo/options"
   )
   func main() {
   	ctx := context.Background()
   	if err := godotenv.Load(); err != nil {
   		log.Fatal("no .env file found")
   	}
   	// Connect to your Atlas cluster
   	uri := os.Getenv("ATLAS_CONNECTION_STRING")
   	if uri == "" {
   		log.Fatal("set your 'ATLAS_CONNECTION_STRING' environment variable.")
   	}
   	clientOptions := options.Client().ApplyURI(uri)
   	client, err := mongo.Connect(ctx, clientOptions)
   	if err != nil {
   		log.Fatalf("failed to connect to the server: %v", err)
   	}
   	defer func() { _ = client.Disconnect(ctx) }()
   	// Specify the database and collection
   	coll := client.Database("rag_db").Collection("test")
   	indexName := "vector_index"
   	opts := options.SearchIndexes().SetName(indexName).SetType("vectorSearch")
   	type vectorDefinitionField struct {
   		Type          string `bson:"type"`
   		Path          string `bson:"path"`
   		NumDimensions int    `bson:"numDimensions"`
   		Similarity    string `bson:"similarity"`
   	}
   	type filterField struct {
   		Type string `bson:"type"`
   		Path string `bson:"path"`
   	}
   	type vectorDefinition struct {
   		Fields []vectorDefinitionField `bson:"fields"`
   	}
   	indexModel := mongo.SearchIndexModel{
   		Definition: vectorDefinition{
   			Fields: []vectorDefinitionField{{
   				Type:          "vector",
   				Path:          "embedding",
   				NumDimensions: 1024,
   				Similarity:    "cosine"}},
   		},
   		Options: opts,
   	}
   	log.Println("Creating the index.")
   	searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel)
   	if err != nil {
   		log.Fatalf("failed to create the search index: %v", err)
   	}
   	// Await the creation of the index.
   	log.Println("Polling to confirm successful index creation.")
   	log.Println("NOTE: This may take up to a minute.")
   	searchIndexes := coll.SearchIndexes()
   	var doc bson.Raw
   	for doc == nil {
   		cursor, err := searchIndexes.List(ctx, options.SearchIndexes().SetName(searchIndexName))
   		if err != nil {
   			log.Printf("failed to list search indexes: %w", err)
   		}
   		if !cursor.Next(ctx) {
   			break
   		}
   		name := cursor.Current.Lookup("name").StringValue()
   		queryable := cursor.Current.Lookup("queryable").Boolean()
   		if name == searchIndexName && queryable {
   			doc = cursor.Current
   		} else {
   			time.Sleep(5 * time.Second)
   		}
   	}
   	log.Println("Name of Index Created: " + searchIndexName)
   }

2. 次のコマンドを実行して、インデックスを作成します。

   go run rag-vector-index.go

3. 関連データを取得するための関数を定義します。

   この手順では、関連するドキュメントを取得するためのクエリを実行するGetQueryResultsという取得関数を作成します。 GetEmbeddingsを使用して、検索クエリから埋め込みを作成します。 次に、クエリを実行してセマンティックで同様のドキュメントを返します。

   詳細については、「ベクトル検索クエリの実行 」を参照してください。

   common ディレクトリに get-query-results.go という新しいファイルを作成し、そのファイルに次のコードを貼り付けます。

   get-クエリ-results.go

   package common
   import (
   	"context"
   	"log"
   	"os"
   	"github.com/joho/godotenv"
   	"go.mongodb.org/mongo-driver/bson"
   	"go.mongodb.org/mongo-driver/mongo"
   	"go.mongodb.org/mongo-driver/mongo/options"
   )
   type TextWithScore struct {
   	PageContent string  `bson:"pageContent"`
   	Score       float64 `bson:"score"`
   }
   func GetQueryResults(query string) []TextWithScore {
   	ctx := context.Background()
   	if err := godotenv.Load(); err != nil {
   		log.Fatal("no .env file found")
   	}
   	// Connect to your Atlas cluster
   	uri := os.Getenv("ATLAS_CONNECTION_STRING")
   	if uri == "" {
   		log.Fatal("set your 'ATLAS_CONNECTION_STRING' environment variable.")
   	}
   	clientOptions := options.Client().ApplyURI(uri)
   	client, err := mongo.Connect(ctx, clientOptions)
   	if err != nil {
   		log.Fatalf("failed to connect to the server: %v", err)
   	}
   	defer func() { _ = client.Disconnect(ctx) }()
   	// Specify the database and collection
   	coll := client.Database("rag_db").Collection("test")
   	queryEmbedding := GetEmbeddings([]string{query})
   	vectorSearchStage := bson.D{
   		{"$vectorSearch", bson.D{
   			{"index", "vector_index"},
   			{"path", "embedding"},
   			{"queryVector", queryEmbedding[0]},
   			{"exact", true},
   			{"limit", 5},
   		}}}
   	projectStage := bson.D{
   		{"$project", bson.D{
   			{"_id", 0},
   			{"pageContent", 1},
   			{"score", bson.D{{"$meta", "vectorSearchScore"}}},
   		}}}
   	cursor, err := coll.Aggregate(ctx, mongo.Pipeline{vectorSearchStage, projectStage})
   	if err != nil {
   		log.Fatalf("failed to execute the aggregation pipeline: %v", err)
   	}
   	var results []TextWithScore
   	if err = cursor.All(context.TODO(), &results); err != nil {
   		log.Fatalf("failed to connect unmarshal retrieved documents: %v", err)
   	}
   	return results
   }

4. データの取得をテストします。

   1. rag-mongodb プロジェクト ディレクトリに、retrieve-documents-test.go という新しいファイルを作成します。この手順では、定義した関数が適切な結果を返すことを確認します。

   2. このコードを ファイルに貼り付けます。

      retrieve-documents-test.go

      package main
      import (
      	"fmt"
      	"rag-mongodb/common" // Module that contains the GetQueryResults function
      )
      func main() {
      	query := "AI Technology"
      	documents := common.GetQueryResults(query)
      	for _, doc := range documents {
      		fmt.Printf("Text: %s \nScore: %v \n\n", doc.PageContent, doc.Score)
      	}
      }

   3. 次のコマンドを実行して、コードを実行します。

      go run retrieve-documents-test.go

      出力を表示

      Text: for the variety and scale of data required by AI-powered applications. We are confident MongoDB will be a substantial beneficiary of this next wave of application development."
      Score: 0.835033655166626
      Text: "As we look ahead, we continue to be incredibly excited by our large market opportunity, the potential to increase share, and become a standard within more of our customers. We also see a tremendous opportunity to win more legacy workloads, as AI has now become a catalyst to modernize these applications. MongoDB's document-based architecture is particularly well-suited for the variety and
      Score: 0.8280757665634155
      Text: to the use of new and evolving technologies, such as artificial intelligence, in our offerings or partnerships; the growth and expansion of the market for database products and our ability to penetrate that market; our ability to integrate acquired businesses and technologies successfully or achieve the expected benefits of such acquisitions; our ability to maintain the security of our software
      Score: 0.8165900111198425
      Text: MongoDB continues to expand its AI ecosystem with the announcement of the MongoDB AI Applications Program (MAAP), which provides customers with reference architectures, pre-built partner integrations, and professional services to help them quickly build AI-powered applications. Accenture will establish a center of excellence focused on MongoDB projects, and is the first global systems
      Score: 0.8023912906646729
      Text: Bendigo and Adelaide Bank partnered with MongoDB to modernize their core banking technology. With the help of MongoDB Relational Migrator and generative AI-powered modernization tools, Bendigo and Adelaide Bank decomposed an outdated consumer-servicing application into microservices and migrated off its underlying legacy relational database technology significantly faster and more easily than
      Score: 0.7959681749343872

LLM を使用して応答を生成します。

このセクションでは、検索されたドキュメントをコンテキストとして使用するよう LLM に指示して応答を 生成 します。この例では、先ほど定義した関数を使用して、一致するドキュメントを データベースから検索し、さらに次のことも行います。

• Misttal7 B 指示 にアクセスする からのモデル化

• プロンプトにユーザーの質問と検索されたドキュメントを含めるようにLLMに指示します。

• LLMMongoDBの最新のAI に関する発表について を要求します。

1. generate-responses.goという新しいファイルを作成し、次のコードをそのファイルに貼り付けます。

   generate-responses.go

   package main
   import (
   	"context"
   	"fmt"
   	"log"
   	"rag-mongodb/common" // Module that contains the GetQueryResults function
   	"strings"
   	"github.com/tmc/langchaingo/llms"
   	"github.com/tmc/langchaingo/llms/huggingface"
   	"github.com/tmc/langchaingo/prompts"
   )
   func main() {
   	ctx := context.Background()
   	query := "AI Technology"
   	documents := common.GetQueryResults(query)
   	var textDocuments strings.Builder
   	for _, doc := range documents {
   		textDocuments.WriteString(doc.PageContent)
   	}
   	question := "In a few sentences, what are MongoDB's latest AI announcements?"
   	template := prompts.NewPromptTemplate(
   		`Answer the following question based on the given context.
   			Question: {{.question}}
   			Context: {{.context}}`,
   		[]string{"question", "context"},
   	)
   	prompt, err := template.Format(map[string]any{
   		"question": question,
   		"context":  textDocuments.String(),
   	})
   	opts := llms.CallOptions{
   		Model:       "mistralai/Mistral-7B-Instruct-v0.3",
   		MaxTokens:   150,
   		Temperature: 0.1,
   	}
   	llm, err := huggingface.New(huggingface.WithModel("mistralai/Mistral-7B-Instruct-v0.3"))
   	if err != nil {
   		log.Fatalf("failed to initialize a Hugging Face LLM: %v", err)
   	}
   	completion, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt, llms.WithOptions(opts))
   	if err != nil {
   		log.Fatalf("failed to generate a response from the prompt: %v", err)
   	}
   	response := strings.Split(completion, "\n\n")
   	if len(response) == 2 {
   		fmt.Printf("Prompt: %v\n\n", response[0])
   		fmt.Printf("Response: %v\n", response[1])
   	}
   }

2. このコマンドを実行してコードを実行します。生成される応答は異なる場合があります。

   go run generate-responses.go

   出力を表示

   Prompt: Answer the following question based on the given context.
   			Question: In a few sentences, what are MongoDB's latest AI announcements?
   			Context: for the variety and scale of data required by AI-powered applications. We are confident MongoDB will be a substantial beneficiary of this next wave of application development.""As we look ahead, we continue to be incredibly excited by our large market opportunity, the potential to increase share, and become a standard within more of our customers. We also see a tremendous opportunity to win more legacy workloads, as AI has now become a catalyst to modernize these applications. MongoDB's document-based architecture is particularly well-suited for the variety andto the use of new and evolving technologies, such as artificial intelligence, in our offerings or partnerships; the growth and expansion of the market for database products and our ability to penetrate that market; our ability to integrate acquired businesses and technologies successfully or achieve the expected benefits of such acquisitions; our ability to maintain the security of our softwareMongoDB continues to expand its AI ecosystem with the announcement of the MongoDB AI Applications Program (MAAP), which provides customers with reference architectures, pre-built partner integrations, and professional services to help them quickly build AI-powered applications. Accenture will establish a center of excellence focused on MongoDB projects, and is the first global systemsBendigo and Adelaide Bank partnered with MongoDB to modernize their core banking technology. With the help of MongoDB Relational Migrator and generative AI-powered modernization tools, Bendigo and Adelaide Bank decomposed an outdated consumer-servicing application into microservices and migrated off its underlying legacy relational database technology significantly faster and more easily than expected.
   Response: MongoDB's latest AI announcements include the launch of the MongoDB AI Applications Program (MAAP) and a partnership with Accenture to establish a center of excellence focused on MongoDB projects. Additionally, Bendigo and Adelaide Bank have partnered with MongoDB to modernize their core banking technology using MongoDB's AI-powered modernization tools.

Javaプロジェクトを作成し、依存関係をインストールします。

1. IDE から、Maven または Gradle を使用してJavaプロジェクトを作成します。

2. パッケージマネージャーに応じて、次の依存関係を追加します。

   Maven

   Gradle

   Maven を使用している場合は、プロジェクトの pom.xmlファイルの dependencies 配列と dependencyManagement 配列に次の依存関係を追加します。

   pom.xml

   <dependencies>
      <!-- MongoDB Java Sync Driver v5.2.0 or later -->
      <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-sync</artifactId>
            <version>[5.2.0,)</version>
      </dependency>
      <!-- Java library for Hugging Face models -->
      <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-hugging-face</artifactId>
      </dependency>
      <!-- Java library for URL Document Loader -->
      <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
      </dependency>
      <!-- Java library for ApachePDFBox Document Parser -->
      <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-document-parser-apache-pdfbox</artifactId>
      </dependency>
   </dependencies>
   <dependencyManagement>
      <dependencies>
            <!-- Bill of Materials (BOM) to manage Java library versions -->
            <dependency>
               <groupId>dev.langchain4j</groupId>
               <artifactId>langchain4j-bom</artifactId>
               <version>0.36.2</version>
               <type>pom</type>
               <scope>import</scope>
            </dependency>
      </dependencies>
   </dependencyManagement>

   Gradle を使用している場合は、プロジェクトの build.gradleファイルの dependencies 配列に次の Bill of Organization（BOM）と依存関係を追加します。

   build.grouple

   dependencies {
      // Bill of Materials (BOM) to manage Java library versions
      implementation platform('dev.langchain4j:langchain4j-bom:0.36.2')
      // MongoDB Java Sync Driver v5.2.0 or later
      implementation 'org.mongodb:mongodb-driver-sync:5.2.0'
      // Java library for Hugging Face models
      implementation 'dev.langchain4j:langchain4j-hugging-face'
      // Java library for URL Document Loader
      implementation 'dev.langchain4j:langchain4j'
      // Java library for Apache PDFBox Document Parser
      implementation 'dev.langchain4j:langchain4j-document-parser-apache-pdfbox'
   }

3. パッケージマネージャーを実行して、プロジェクトに依存関係をインストールします。

環境変数を設定します。

IDE で新しい構成テンプレートを作成し、次の変数をプロジェクトに追加します 。

• IntelliJ IDEA を使用している場合は、新しい Application 実行構成テンプレートを作成し、Environment variablesフィールドに変数をセミコロン区切りの値として追加します（例:、FOO=123;BAR=456）。変更を適用し、[ OK ] をクリックします。

  詳細については、IntelliJ IDEA ドキュメントの「 テンプレートから実行/デバッグ構成を作成する 」セクションを参照してください。

• Eclipse を使用している場合は、新しい Java Application 起動構成を作成し、各変数を新しいキーと値のペアとして Environmentタブに追加します。変更を適用し、[ OK ] をクリックします。

  詳細については、Eclipse IDE ドキュメントの「 Javaアプリケーション起動構成の作成 」セクションを参照してください。

   HUGGING_FACE_ACCESS_TOKEN=<access-token>
   ATLAS_CONNECTION_STRING=<connection-string>

プレースホルダーを次の値で更新します。

• <access-token> プレースホルダー値を 1 つのドキュメント アクセス トークンに置き換えます。

• <connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

  接続stringには、次の形式を使用する必要があります。

  mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net

データを解析して分裂するメソッドを定義します。

PDFProcessor.javaという名前のファイルを作成し、次のコードを貼り付けます。

このコードでは、次のメソッドを定義します。

• parsePDFDocumentメソッドは、 Apache PDFBox ライブラリと Lgachein j URLドキュメント ローダーを使用して、指定されたURLで4 PDFファイルを読み込み、解析します。メソッドは解析された PDF を lang チェーン4 j ドキュメントとして返します。

• splitDocumentメソッドは、指定された lang チェーン4 j ドキュメントを、指定されたチャンク サイズ（文字数）と チャンク重複 （連続するチャンク間で重複する文字数）に従ってチャンクに分割します。メソッドは、テキスト セグメントのリストを返します。

import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.DocumentParser;
import dev.langchain4j.data.document.DocumentSplitter;
import dev.langchain4j.data.document.loader.UrlDocumentLoader;
import dev.langchain4j.data.document.parser.apache.pdfbox.ApachePdfBoxDocumentParser;
import dev.langchain4j.data.document.splitter.DocumentByCharacterSplitter;
import dev.langchain4j.data.segment.TextSegment;
import java.util.List;
public class PDFProcessor {
    /** Parses a PDF document from the specified URL, and returns a
     * langchain4j Document object.
     * */
    public static Document parsePDFDocument(String url) {
        DocumentParser parser = new ApachePdfBoxDocumentParser();
        return UrlDocumentLoader.load(url, parser);
    }
    /** Splits a parsed langchain4j Document based on the specified chunking
     * parameters, and returns an array of text segments.
     */
    public static List<TextSegment> splitDocument(Document document) {
        int maxChunkSize = 400; // number of characters
        int maxChunkOverlap = 20; // number of overlapping characters between consecutive chunks
        DocumentSplitter splitter = new DocumentByCharacterSplitter(maxChunkSize, maxChunkOverlap);
        return splitter.split(document);
    }
}

ベクトル埋め込みを生成する方法を定義します。

EmbeddingProvider.javaという名前のファイルを作成し、次のコードを貼り付けます。

このコードでは、mxます。1

• 複数の入力:getEmbeddings メソッドはテキスト セグメント入力の配列（List<TextSegment> ）を受け入れるため、1 回のAPI呼び出しに複数の埋め込みを作成できます。このメソッドは、 APIが提供する浮動小数点数の配列を、Atlas クラスターに保存するために double のBSON配列に変換します。

• 単一入力:getEmbedding Stringメソッドは単一の を受け入れます。これはベクトルデータに対して実行するクエリを表します。メソッドは、 APIが提供する浮動小数点数の配列を、コレクションをクエリするときに使用する double のBSON配列に変換します 。

import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.huggingface.HuggingFaceChatModel;
import dev.langchain4j.model.huggingface.HuggingFaceEmbeddingModel;
import dev.langchain4j.model.output.Response;
import org.bson.BsonArray;
import org.bson.BsonDouble;
import java.util.List;
import static java.time.Duration.ofSeconds;
public class EmbeddingProvider {
    private static HuggingFaceEmbeddingModel embeddingModel;
    private static HuggingFaceEmbeddingModel getEmbeddingModel() {
        if (embeddingModel == null) {
            String accessToken = System.getenv("HUGGING_FACE_ACCESS_TOKEN");
            if (accessToken == null || accessToken.isEmpty()) {
                throw new RuntimeException("HUGGING_FACE_ACCESS_TOKEN env variable is not set or is empty.");
            }
            embeddingModel = HuggingFaceEmbeddingModel.builder()
                    .accessToken(accessToken)
                    .modelId("mixedbread-ai/mxbai-embed-large-v1")
                    .waitForModel(true)
                    .timeout(ofSeconds(60))
                    .build();
        }
        return embeddingModel;
    }
    /**
     * Returns the Hugging Face chat model interface used by the createPrompt() method
     * to process queries and generate responses.
     */
    private static HuggingFaceChatModel chatModel;
    public static HuggingFaceChatModel getChatModel() {
        String accessToken = System.getenv("HUGGING_FACE_ACCESS_TOKEN");
        if (accessToken == null || accessToken.isEmpty()) {
            throw new IllegalStateException("HUGGING_FACE_ACCESS_TOKEN env variable is not set or is empty.");
        }
        if (chatModel == null) {
            chatModel = HuggingFaceChatModel.builder()
                    .timeout(ofSeconds(25))
                    .modelId("mistralai/Mistral-7B-Instruct-v0.3")
                    .temperature(0.1)
                    .maxNewTokens(150)
                    .accessToken(accessToken)
                    .waitForModel(true)
                    .build();
        }
        return chatModel;
    }
    /**
     * Takes an array of text segments and returns a BSON array of embeddings to
     * store in the database.
     */
    public List<BsonArray> getEmbeddings(List<TextSegment> texts) {
        List<TextSegment> textSegments = texts.stream()
                .toList();
        Response<List<Embedding>> response = getEmbeddingModel().embedAll(textSegments);
        return response.content().stream()
                .map(e -> new BsonArray(
                        e.vectorAsList().stream()
                                .map(BsonDouble::new)
                                .toList()))
                .toList();
    }
    /**
     * Takes a single string and returns a BSON array embedding to
     * use in a vector query.
     */
    public static BsonArray getEmbedding(String text) {
        Response<Embedding> response = getEmbeddingModel().embed(text);
        return new BsonArray(
                response.content().vectorAsList().stream()
                        .map(BsonDouble::new)
                        .toList());
    }
}

Atlas にデータを取り込む方法を定義します。

DataIngest.javaという名前のファイルを作成し、次のコードを貼り付けます。

このコードでは、Lgachein 4j ライブラリとMongoDB Java Sync Driver を使用して、LM がアクセスできないサンプルデータを Atlas に取り込みます。

具体的には、このコードでは次の処理が行われます。

1. Atlas クラスターへの接続

2. 以前に定義した メソッドを使用して、 URLからMongoDB収益レポート PDFファイルを読み込み、解析します。parsePDFDocument

3. 以前に定義した splitDocument メソッドを使用してデータをチャンクに分割します。

4. 以前に定義した GetEmbeddings メソッドを使用して、チャンク データからベクトル埋め込みを作成します。

5. Atlas クラスターの rag_db.testコレクションに、チャンクされたデータと一緒に埋め込みを保存します。

   DataIngest.java

   import com.mongodb.MongoException;
   import com.mongodb.client.MongoClient;
   import com.mongodb.client.MongoClients;
   import com.mongodb.client.MongoCollection;
   import com.mongodb.client.MongoDatabase;
   import com.mongodb.client.result.InsertManyResult;
   import dev.langchain4j.data.segment.TextSegment;
   import org.bson.BsonArray;
   import org.bson.Document;
   import java.util.ArrayList;
   import java.util.List;
   public class DataIngest {
       public static void main(String[] args) {
           String uri = System.getenv("ATLAS_CONNECTION_STRING");
           if (uri == null || uri.isEmpty()) {
               throw new RuntimeException("ATLAS_CONNECTION_STRING env variable is not set or is empty.");
           }
           // establish connection and set namespace
           try (MongoClient mongoClient = MongoClients.create(uri)) {
               MongoDatabase database = mongoClient.getDatabase("rag_db");
               MongoCollection<Document> collection = database.getCollection("test");
               // parse the PDF file at the specified URL
               String url = "https://investors.mongodb.com/node/12236/pdf";
               String fileName = "mongodb_annual_report.pdf";
               System.out.println("Parsing the [" + fileName + "] file from url: " + url);
               dev.langchain4j.data.document.Document parsedDoc = PDFProcessor.parsePDFDocument(url);
               // split (or "chunk") the parsed document into text segments
               List<TextSegment> segments = PDFProcessor.splitDocument(parsedDoc);
               System.out.println(segments.size() + " text segments created successfully.");
               
               // create vector embeddings from the chunked data (i.e. text segments)
               System.out.println("Creating vector embeddings from the parsed data segments. This may take a few moments.");
               List<Document> documents = embedText(segments);
               // insert the embeddings into the Atlas collection
               try {
                   System.out.println("Ingesting data into the " + collection.getNamespace() + " collection.");
                   insertDocuments(documents, collection);
               }
               catch (MongoException me) {
                   throw new RuntimeException("Failed to insert documents", me);
               }
           } catch (MongoException me) {
               throw new RuntimeException("Failed to connect to MongoDB", me);
           } catch (Exception e) {
               throw new RuntimeException("Operation failed: ", e);
           }
       }
       
       /** 
        * Embeds text segments into vector embeddings using the EmbeddingProvider
        * class and returns a list of BSON documents containing the text and 
        * generated embeddings.
       */
       private static List<Document> embedText(List<TextSegment> segments) {
           EmbeddingProvider embeddingProvider = new EmbeddingProvider();
           List<BsonArray> embeddings = embeddingProvider.getEmbeddings(segments);
           List<Document> documents = new ArrayList<>();
           int i = 0;
           for (TextSegment segment : segments) {
               Document doc = new Document("text", segment.text()).append("embedding", embeddings.get(i));
               documents.add(doc);
               i++;
           }
           return documents;
       }
       /**
        * Inserts a list of BSON documents into the specified MongoDB collection.
        */
       private static void insertDocuments(List<Document> documents, MongoCollection<Document> collection) {
           List<String> insertedIds = new ArrayList<>();
           InsertManyResult result = collection.insertMany(documents);
           result.getInsertedIds().values()
                   .forEach(doc -> insertedIds.add(doc.toString()));
           System.out.println(insertedIds.size() + " documents inserted into the " + collection.getNamespace() + " collection successfully.");
       }
   }

埋め込みを生成します。

DataIngest.javaファイルを保存して実行します。出力は次のようになります。

Parsing the [mongodb_annual_report.pdf] file from url: https://investors.mongodb.com/node/12236/pdf
72 text segments created successfully.
Creating vector embeddings from the parsed data segments. This may take a few moments...
Ingesting data into the rag_db.test collection.
72 documents inserted into the rag_db.test collection successfully.

Atlas Vector Search を使用してドキュメントを検索します。

このセクションでは、Atlas ベクトル検索を設定してベクトルデータベースからドキュメントを検索します。

1. VectorIndex.javaという名前のファイルを作成し、次のコードを貼り付けます。

   このコードでは、次のインデックス定義を使用してコレクションに Atlas ベクトル検索インデックスが作成されます。

   • embeddingrag_db.testコレクションのベクトルインデックスタイプで フィールドをインデックス化します。このフィールドには、埋め込みモデルを使用して作成された埋め込みが含まれます。

   • 1024ベクトル次元を強制し、cosine を使用してベクトル間の類似性を測定します。

   VectorIndex.java

   import com.mongodb.MongoException;
   import com.mongodb.client.ListSearchIndexesIterable;
   import com.mongodb.client.MongoClient;
   import com.mongodb.client.MongoClients;
   import com.mongodb.client.MongoCollection;
   import com.mongodb.client.MongoCursor;
   import com.mongodb.client.MongoDatabase;
   import com.mongodb.client.model.SearchIndexModel;
   import com.mongodb.client.model.SearchIndexType;
   import org.bson.Document;
   import org.bson.conversions.Bson;
   import java.util.Collections;
   import java.util.List;
   public class VectorIndex {
       public static void main(String[] args) {
           String uri = System.getenv("ATLAS_CONNECTION_STRING");
           if (uri == null || uri.isEmpty()) {
               throw new IllegalStateException("ATLAS_CONNECTION_STRING env variable is not set or is empty.");
           }
           // establish connection and set namespace
           try (MongoClient mongoClient = MongoClients.create(uri)) {
               MongoDatabase database = mongoClient.getDatabase("rag_db");
               MongoCollection<Document> collection = database.getCollection("test");
               // define the index details for the index model
               String indexName = "vector_index";
               Bson definition = new Document(
                       "fields",
                       Collections.singletonList(
                               new Document("type", "vector")
                                       .append("path", "embedding")
                                       .append("numDimensions", 1024)
                                       .append("similarity", "cosine")));
               SearchIndexModel indexModel = new SearchIndexModel(
                       indexName,
                       definition,
                       SearchIndexType.vectorSearch());
               // create the index using the defined model
               try {
                   List<String> result = collection.createSearchIndexes(Collections.singletonList(indexModel));
                   System.out.println("Successfully created vector index named: " + result);
                   System.out.println("It may take up to a minute for the index to build before you can query using it.");
               } catch (Exception e) {
                   throw new RuntimeException(e);
               }
               // wait for Atlas to build the index and make it queryable
               System.out.println("Polling to confirm the index has completed building.");
               waitForIndexReady(collection, indexName);
           } catch (MongoException me) {
               throw new RuntimeException("Failed to connect to MongoDB", me);
           } catch (Exception e) {
               throw new RuntimeException("Operation failed: ", e);
           }
       }
       /**
        * Polls the collection to check whether the specified index is ready to query.
        */
       public static void waitForIndexReady(MongoCollection<Document> collection, String indexName) throws InterruptedException {
           ListSearchIndexesIterable<Document> searchIndexes = collection.listSearchIndexes();
           while (true) {
               try (MongoCursor<Document> cursor = searchIndexes.iterator()) {
                   if (!cursor.hasNext()) {
                       break;
                   }
                   Document current = cursor.next();
                   String name = current.getString("name");
                   boolean queryable = current.getBoolean("queryable");
                   if (name.equals(indexName) && queryable) {
                       System.out.println(indexName + " index is ready to query");
                       return;
                   } else {
                       Thread.sleep(500);
                   }
               }
           }
       }
   }

2. Atlas Vector Search インデックスを作成します。

   ファイルを保存して実行します。 出力は次のようになります。

   Successfully created a vector index named: [vector_index]
   Polling to confirm the index has completed building.
   It may take up to a minute for the index to build before you can query using it.
   vector_index index is ready to query

LM を使用して応答を生成するコードを作成します。

このセクションでは、検索されたドキュメントをコンテキストとして使用するよう LLM に指示して応答を生成します。

LLMPrompt.java という新しいファイルを作成し、次のコードをそのファイルに貼り付けます。

このコードでは、次の処理が行われます。

1. retrieveDocuments メソッドを使用して、rag_db.testコレクションで一致するドキュメントをクエリします。

   このメソッドは、先ほど作成した getEmbedding メソッドを使用して検索クエリーから埋め込みを生成し、 クエリを実行してセマンティック ドキュメントを返します。

   詳細については、「ベクトル検索クエリの実行 」を参照してください。

2. Hugeface のモデル ハブから Mistreal7 B 指示モデルにアクセスし、createPrompt メソッドを使用してテンプレート化されたプロンプトを作成します。

   メソッドは、定義されたプロンプトにユーザーの質問と検索されたドキュメントを含めるように LM に指示します。

3. MongoDB の最新のAI発表に関する LM を要求し、生成された応答を返します。

   LLMPrompt.java

   import com.mongodb.MongoException;
   import com.mongodb.client.MongoClient;
   import com.mongodb.client.MongoClients;
   import com.mongodb.client.MongoCollection;
   import com.mongodb.client.MongoDatabase;
   import com.mongodb.client.model.search.FieldSearchPath;
   import dev.langchain4j.data.message.AiMessage;
   import dev.langchain4j.model.huggingface.HuggingFaceChatModel;
   import dev.langchain4j.model.input.Prompt;
   import dev.langchain4j.model.input.PromptTemplate;
   import org.bson.BsonArray;
   import org.bson.BsonValue;
   import org.bson.Document;
   import org.bson.conversions.Bson;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import static com.mongodb.client.model.Aggregates.project;
   import static com.mongodb.client.model.Aggregates.vectorSearch;
   import static com.mongodb.client.model.Projections.exclude;
   import static com.mongodb.client.model.Projections.fields;
   import static com.mongodb.client.model.Projections.include;
   import static com.mongodb.client.model.Projections.metaVectorSearchScore;
   import static com.mongodb.client.model.search.SearchPath.fieldPath;
   import static com.mongodb.client.model.search.VectorSearchOptions.exactVectorSearchOptions;
   import static java.util.Arrays.asList;
   public class LLMPrompt {
       // User input: the question to answer
       static String question = "In a few sentences, what are MongoDB's latest AI announcements?";
       public static void main(String[] args) {
           String uri = System.getenv("ATLAS_CONNECTION_STRING");
           if (uri == null || uri.isEmpty()) {
               throw new IllegalStateException("ATLAS_CONNECTION_STRING env variable is not set or is empty.");
           }
           // establish connection and set namespace
           try (MongoClient mongoClient = MongoClients.create(uri)) {
               MongoDatabase database = mongoClient.getDatabase("rag_db");
               MongoCollection<Document> collection = database.getCollection("test");
               // generate a response to the user question
               try {
                   createPrompt(question, collection);
               } catch (Exception e) {
                   throw new RuntimeException("An error occurred while generating the response: ", e);
               }
           } catch (MongoException me) {
               throw new RuntimeException("Failed to connect to MongoDB ", me);
           } catch (Exception e) {
               throw new RuntimeException("Operation failed: ", e);
           }
       }
       /**
        * Returns a list of documents from the specified MongoDB collection that
        * match the user's question.
        * NOTE: Update or omit the projection stage to change the desired fields in the response
        */
       public static List<Document> retrieveDocuments(String question, MongoCollection<Document> collection) {
           try {
               // generate the query embedding to use in the vector search
               BsonArray queryEmbeddingBsonArray = EmbeddingProvider.getEmbedding(question);
               List<Double> queryEmbedding = new ArrayList<>();
               for (BsonValue value : queryEmbeddingBsonArray.stream().toList()) {
                   queryEmbedding.add(value.asDouble().getValue());
               }
               // define the pipeline stages for the vector search index
               String indexName = "vector_index";
               FieldSearchPath fieldSearchPath = fieldPath("embedding");
               int limit = 5;
               List<Bson> pipeline = asList(
                       vectorSearch(
                               fieldSearchPath,
                               queryEmbedding,
                               indexName,
                               limit,
                               exactVectorSearchOptions()),
                       project(
                               fields(
                                       exclude("_id"),
                                       include("text"),
                                       metaVectorSearchScore("score"))));
               // run the query and return the matching documents
               List<Document> matchingDocuments = new ArrayList<>();
               collection.aggregate(pipeline).forEach(matchingDocuments::add);
               return matchingDocuments;
           } catch (Exception e) {
               System.err.println("Error occurred while retrieving documents: " + e.getMessage());
               return new ArrayList<>();
           }
       }
       /**
        * Creates a templated prompt from a submitted question string and any retrieved documents,
        * then generates a response using the Hugging Face chat model.
        */
       public static void createPrompt(String question, MongoCollection<Document> collection) {
           // retrieve documents matching the user's question
           List<Document> retrievedDocuments = retrieveDocuments(question, collection);
           if (retrievedDocuments.isEmpty()) {
               System.out.println("No relevant documents found. Unable to generate a response.");
               return;
           } else
               System.out.println("Generating a response from the retrieved documents. This may take a few moments.");
           // define a prompt template
           HuggingFaceChatModel huggingFaceChatModel = EmbeddingProvider.getChatModel();
           PromptTemplate promptBuilder = PromptTemplate.from("""
                   Answer the following question based on the given context:
                   Question: {{question}}
                   Context: {{information}}
                   -------
                   """);
           // build the information string from the retrieved documents
           StringBuilder informationBuilder = new StringBuilder();
           for (Document doc : retrievedDocuments) {
               String text = doc.getString("text");
               informationBuilder.append(text).append("\n");
           }
           Map<String, Object> variables = new HashMap<>();
           variables.put("question", question);
           variables.put("information", informationBuilder);
           // generate and output the response from the chat model
           Prompt prompt = promptBuilder.apply(variables);
           AiMessage response = huggingFaceChatModel.generate(prompt.toUserMessage()).content();
           // extract the generated text to output a formatted response
           String responseText = response.text();
           String marker = "-------";
           int markerIndex = responseText.indexOf(marker);
           String generatedResponse;
           if (markerIndex != -1) {
               generatedResponse = responseText.substring(markerIndex + marker.length()).trim();
           } else {
               generatedResponse = responseText; // else fallback to the full response
           }
           // output the question and formatted response
           System.out.println("Question:\n " + question);
           System.out.println("Response:\n " + generatedResponse);
           // output the filled-in prompt and context information for demonstration purposes
           System.out.println("\n" + "---- Prompt Sent to LLM ----");
           System.out.println(prompt.text() + "\n");
       }
   }

LLM を使用して応答を生成します。

ファイルを保存して実行しファイル。出力は次のようになりますが、生成される応答は異なる場合があることに注意してください。

Generating a response from the retrieved documents. This may take a few moments.
Question:
 In a few sentences, what are MongoDB's latest AI announcements?
Response:
 MongoDB's latest AI announcements include the MongoDB AI Applications Program (MAAP), which provides customers with reference architectures, pre-built partner integrations, and professional services to help them quickly build AI-powered applications. Accenture will establish a center of excellence focused on MongoDB projects. These announcements highlight MongoDB's growing focus on AI application development and its potential to modernize legacy workloads.
---- Prompt Sent to LLM ----
Answer the following question based on the given context:
Question: In a few sentences, what are MongoDB's latest AI announcements?
Context: time data.
MongoDB continues to expand its AI ecosystem with the announcement of the MongoDB AI Applications Program (MAAP),
which provides customers with reference architectures, pre-built partner integrations, and professional services to help
them quickly build AI-powered applications. Accenture will establish a center of excellence focused on MongoDB projects,
and is the first global systems i
ighlights
MongoDB announced a number of new products and capabilities at MongoDB.local NYC. Highlights included the preview
of MongoDB 8.0—with significant performance improvements such as faster reads and updates, along with significantly
faster bulk inserts and time series queries—and the general availability of Atlas Stream Processing to build sophisticated,
event-driven applications with real-
ble future as well as the criticality of MongoDB to artificial intelligence application development. These forward-looking
statements include, but are not limited to, plans, objectives, expectations and intentions and other statements contained in this press release that are
not historical facts and statements identified by words such as "anticipate," "believe," "continue," "could," "estimate," "e
ve Officer of MongoDB.
"As we look ahead, we continue to be incredibly excited by our large market opportunity, the potential to increase share, and become a standard within
more of our customers. We also see a tremendous opportunity to win more legacy workloads, as AI has now become a catalyst to modernize these
applications. MongoDB's document-based architecture is particularly well-suited for t
ictable, impact on its future GAAP financial results.
Conference Call Information
MongoDB will host a conference call today, May 30, 2024, at 5:00 p.m. (Eastern Time) to discuss its financial results and business outlook. A live
webcast of the call will be available on the "Investor Relations" page of MongoDB's website at https://investors.mongodb.com. To access the call by
phone, please go to thi

環境を設定します。

1. Node.js プロジェクトを初期化します。

   ターミナルで次のコマンドを実行して、 rag-mongodbという名前の新しいディレクトリを作成し、プロジェクトを初期化します。

   mkdir rag-mongodb
   cd rag-mongodb
   npm init -y

2. 依存関係をインストールしてインポートします。

   次のコマンドを実行します:

   npm install mongodb langchain @langchain/community @xenova/transformers @huggingface/inference pdf-parse

3. package.jsonファイルを更新します。

   プロジェクトのpackage.jsonファイルで、次の例に示すようにtypeフィールドを指定し、ファイルを保存します。

   {
      "name": "rag-mongodb",
      "type": "module",
      ...

4. .envファイルを作成します。

   プロジェクトで、 Atlas 接続文字列と Hugeface アクセス トークンを保存するための .env ファイルを作成します。

   HUGGING_FACE_ACCESS_TOKEN = "<access-token>"
   ATLAS_CONNECTION_STRING = "<connection-string>"
   Replace the ``<access-token>`` placeholder value with your Hugging Face access token.
   .. include:: /includes/avs-examples/shared/avs-replace-connection-string.rst

   注意

   Node.js の最低バージョン要件

   Node.js v20.x は、--env-file オプションを導入しました。古いバージョンの Node.js を使用している場合は、dotenv パッケージをプロジェクトに追加するか、別の方法を使用して環境変数を管理します。

ベクトル埋め込みを生成する関数を作成します。

このセクションでは、次の関数を作成します。

• noomic- embedded-text-v1 を ロードする 埋め込みモデルを使用する。

• 入力データからベクトル埋め込みを作成します。

プロジェクトにget-embeddings.jsというファイルを作成し、次のコードを貼り付けます。

import { pipeline } from '@xenova/transformers';
// Function to generate embeddings for a given data source
export async function getEmbedding(data) {
    const embedder = await pipeline(
        'feature-extraction', 
        'Xenova/nomic-embed-text-v1');
    const results = await embedder(data, { pooling: 'mean', normalize: true });
    return Array.from(results.data);
}

Atlas にデータを取り込みます。

このセクションでは、 がアクセスできないサンプル データを に 取り込みAtlas LLMます。次のコードでは、 Lgachein 統合とNode.js ドライバーを使用して次の処理を実行します。

• MongoDB のレポートを含む PDF を読み込みます。

• データをチャンクに分割し、チャンク サイズ（文字数）とチャンクの重複（連続するチャンク間で重複する文字数）を指定します。

• 定義したgetEmbeddings関数を使用して、チャンク データからベクトル埋め込みを作成します。

• これらの埋め込みを、Atlas クラスターのrag_db.testコレクション内のチャンク データと一緒に保存します。

プロジェクトにingest-data.jsというファイルを作成し、次のコードを貼り付けます。

import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { MongoClient } from 'mongodb';
import { getEmbeddings } from './get-embeddings.js';
import * as fs from 'fs';
async function run() {
    const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
    try {
        // Save online PDF as a file
        const rawData = await fetch("https://investors.mongodb.com/node/12236/pdf");
        const pdfBuffer = await rawData.arrayBuffer();
        const pdfData = Buffer.from(pdfBuffer);
        fs.writeFileSync("investor-report.pdf", pdfData);
        const loader = new PDFLoader(`investor-report.pdf`);
        const data = await loader.load();
        // Chunk the text from the PDF
        const textSplitter = new RecursiveCharacterTextSplitter({
            chunkSize: 400,
            chunkOverlap: 20,
          });
        const docs = await textSplitter.splitDocuments(data);
        console.log(`Successfully chunked the PDF into ${docs.length} documents.`);
        // Connect to your Atlas cluster
        await client.connect();
        const db = client.db("rag_db");
        const collection = db.collection("test");
        console.log("Generating embeddings and inserting documents.");
        let docCount = 0;
        await Promise.all(docs.map(async doc => {
            const embeddings = await getEmbeddings(doc.pageContent);
            
            // Insert the embeddings and the chunked PDF data into Atlas
            await collection.insertOne({
                document: doc,
                embedding: embeddings,
            });
            docCount += 1;
        }))
        console.log(`Successfully inserted ${docCount} documents.`);
    } catch (err) {
        console.log(err.stack);
    }
    finally {
        await client.close();
    }
}
run().catch(console.dir);

次に、次のコマンドを実行してコードを実行します。

node --env-file=.env ingest-data.js

Atlas Vector Search を使用してドキュメントを検索します。

このセクションでは、Atlas Vector Search を設定してベクトルデータベースからドキュメントを検索します。 次の手順を実行します。

1. ベクトル埋め込みに Atlas Vector Search インデックスを作成します。

   rag-vector-index.jsという名前の新しいファイルを作成し、次のコードを貼り付けます。 このコードは Atlas クラスターに接続し、 rag_db.testコレクションにvectorSearchタイプのインデックスを作成します。

   import { MongoClient } from 'mongodb';
   // Connect to your Atlas cluster
   const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
   async function run() {
       try {
         const database = client.db("rag_db");
         const collection = database.collection("test");
        
         // Define your Atlas Vector Search index
         const index = {
             name: "vector_index",
             type: "vectorSearch",
             definition: {
               "fields": [
                 {
                   "type": "vector",
                   "numDimensions": 768,
                   "path": "embedding",
                   "similarity": "cosine"
                 }
               ]
             }
         }
    
         // Call the method to create the index
         const result = await collection.createSearchIndex(index);
         console.log(result);
       } finally {
         await client.close();
       }
   }
   run().catch(console.dir);

   次に、次のコマンドを実行してコードを実行します。

   node --env-file=.env rag-vector-index.js

2. 関連データを取得するための関数を定義します。

   retrieve-documents.jsという新しいファイルを作成します。

   この手順では、関連するドキュメントを取得するためのクエリを実行するgetQueryResultsという取得関数を作成します。 getEmbeddingsを使用して、検索クエリから埋め込みを作成します。 次に、クエリを実行してセマンティックで同様のドキュメントを返します。

   詳細については、「ベクトル検索クエリの実行 」を参照してください。

   このコードを ファイルに貼り付けます。

   import { MongoClient } from 'mongodb';
   import { getEmbeddings } from './get-embeddings.js';
   // Function to get the results of a vector query
   export async function getQueryResults(query) {
       // Connect to your Atlas cluster
       const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
       
       try {
           // Get embeddings for a query
           const queryEmbeddings = await getEmbeddings(query);
           await client.connect();
           const db = client.db("rag_db");
           const collection = db.collection("test");
           const pipeline = [
               {
                   $vectorSearch: {
                       index: "vector_index",
                       queryVector: queryEmbeddings,
                       path: "embedding",
                       exact: true,
                       limit: 5
                   }
               },
               {
                   $project: {
                       _id: 0,
                       document: 1,
                   }
               }
           ];
           // Retrieve documents from Atlas using this Vector Search query
           const result = collection.aggregate(pipeline);
           const arrayOfQueryDocs = [];
           for await (const doc of result) {
               arrayOfQueryDocs.push(doc);
           }
           return arrayOfQueryDocs;
       } catch (err) {
           console.log(err.stack);
       }
       finally {
           await client.close();
       }
   }

3. データの取得をテストします。

   retrieve-documents-test.jsという新しいファイルを作成します。 この手順では、定義した関数が関連する結果を返すことを確認します。

   このコードを ファイルに貼り付けます。

   import { getQueryResults } from './retrieve-documents.js';
   async function run() {
       try {
           const query = "AI Technology";
           const documents = await getQueryResults(query);
           documents.forEach( doc => {
               console.log(doc);
           }); 
       } catch (err) {
           console.log(err.stack);
       }
   }
   run().catch(console.dir);

   次に、次のコマンドを実行してコードを実行します。

   node --env-file=.env retrieve-documents-test.js

   出力を表示

   {
     document: {
       pageContent: 'MongoDB continues to expand its AI ecosystem with the announcement of the MongoDB AI Applications Program (MAAP),',
       metadata: { source: 'investor-report.pdf', pdf: [Object], loc: [Object] },
       id: null
     }
   }
   {
     document: {
       pageContent: 'artificial intelligence, in our offerings or partnerships; the growth and expansion of the market for database products and our ability to penetrate that\n' +
         'market; our ability to integrate acquired businesses and technologies successfully or achieve the expected benefits of such acquisitions; our ability to',
       metadata: { source: 'investor-report.pdf', pdf: [Object], loc: [Object] },
       id: null
     }
   }
   {
     document: {
       pageContent: 'more of our customers. We also see a tremendous opportunity to win more legacy workloads, as AI has now become a catalyst to modernize these\n' +
         "applications. MongoDB's document-based architecture is particularly well-suited for the variety and scale of data required by AI-powered applications. \n" +
         'We are confident MongoDB will be a substantial beneficiary of this next wave of application development."',
       metadata: { source: 'investor-report.pdf', pdf: [Object], loc: [Object] },
       id: null
     }
   }
   {
     document: {
       pageContent: 'which provides customers with reference architectures, pre-built partner integrations, and professional services to help\n' +
         'them quickly build AI-powered applications. Accenture will establish a center of excellence focused on MongoDB projects,\n' +
         'and is the first global systems integrator to join MAAP.',
       metadata: { source: 'investor-report.pdf', pdf: [Object], loc: [Object] },
       id: null
     }
   }
   {
     document: {
       pageContent: 'Bendigo and Adelaide Bank partnered with MongoDB to modernize their core banking technology. With the help of\n' +
         'MongoDB Relational Migrator and generative AI-powered modernization tools, Bendigo and Adelaide Bank decomposed an\n' +
         'outdated consumer-servicing application into microservices and migrated off its underlying legacy relational database',
       metadata: { source: 'investor-report.pdf', pdf: [Object], loc: [Object] },
       id: null
     }
   }

LLM を使用して応答を生成します。

このセクションでは、検索されたドキュメントをコンテキストとして使用するよう LLM に指示して応答を 生成 します。この例では、先ほど定義した関数を使用して、一致するドキュメントを データベースから検索し、さらに次のことも行います。

• Misttal7 B 指示 にアクセスする からのモデル化

• プロンプトにユーザーの質問と検索されたドキュメントを含めるようにLLMに指示します。

• LLMMongoDBの最新のAI に関する発表について を要求します。

generate-responses.jsという新しいファイルを作成し、次のコードをそのファイルに貼り付けます。

import { getQueryResults } from './retrieve-documents.js';
import { HfInference } from '@huggingface/inference'
async function run() {
    try {
        // Specify search query and retrieve relevant documents
        const query = "AI Technology";
        const documents = await getQueryResults(query);
        // Build a string representation of the retrieved documents to use in the prompt
        let textDocuments = "";
        documents.forEach(doc => {
            textDocuments += doc.document.pageContent;
        });
        const question = "In a few sentences, what are MongoDB's latest AI announcements?";
        // Create a prompt consisting of the question and context to pass to the LLM
        const prompt = `Answer the following question based on the given context.
            Question: {${question}}
            Context: {${textDocuments}}
        `;
        // Connect to Hugging Face, using the access token from the environment file
        const hf = new HfInference(process.env.HUGGING_FACE_ACCESS_TOKEN);
        const llm = hf.endpoint(
            "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
           );
        
        // Prompt the LLM to answer the question using the
        // retrieved documents as the context
        const output = await llm.chatCompletion({
            model: "mistralai/Mistral-7B-Instruct-v0.2",
            messages: [{ role: "user", content: prompt }],
            max_tokens: 150,
        });
        // Output the LLM's response as text.
        console.log(output.choices[0].message.content);
    } catch (err) {
        console.log(err.stack);
    }
}
run().catch(console.dir);

次に、このコマンドを実行してコードを実行します。 生成される応答は異なる場合があります。

node --env-file=.env generate-responses.js

MongoDB's latest AI announcements include the launch of the MongoDB
AI Applications Program (MAAP), which provides customers with
reference architectures, pre-built partner integrations, and
professional services to help them build AI-powered applications
quickly. Accenture has joined MAAP as the first global systems
integrator, establishing a center of excellence focused on MongoDB
projects. Additionally, Bendigo and Adelaide Bank have partnered
with MongoDB to modernize their core banking technology using
MongoDB's Relational Migrator and generative AI-powered
modernization tools.

環境を設定します。

.ipynb 拡張機能を持つファイルを保存して、インタラクティブな Python ノートブックを作成します。このノートブックで、 Python コード スニペットを個別に実行できます。ノートブックで次のコードを実行して、このチュートリアルのための依存関係をインストールします。

pip install --quiet --upgrade pymongo sentence_transformers einops langchain langchain_community pypdf huggingface_hub

Atlas にデータを取り込みます。

このセクションでは、LLM がアクセスできないサンプルデータを Atlas に取り込みます。ノートブックに次の各コード スニペットを貼り付けて実行します。

1. ベクトル埋め込みを生成する関数を定義する。

   このコードを実行して、オープンソースの埋め込みモデルを使用してベクトル埋め込みを生成する関数を作成します。具体的には、このコードでは次の処理が行われます。

   • Sentence Transformers から nomic-embed-text-v1 埋め込みモデルをロードします。

   • モデルを使用して特定のテキスト入力の埋め込みを生成する、 get_embeddingという名前の関数を作成します。

   from sentence_transformers import SentenceTransformer
   # Load the embedding model (https://huggingface.co/nomic-ai/nomic-embed-text-v1")
   model = SentenceTransformer("nomic-ai/nomic-embed-text-v1", trust_remote_code=True)
       
   # Define a function to generate embeddings
   def get_embedding(data):
       """Generates vector embeddings for the given data."""
       embedding = model.encode(data)
       return embedding.tolist()

2. データをロードして分割します。

   このコードを実行すると、LangChain 統合を使用してサンプル データをロードし、分割できます。具体的には、このコードでは次の処理が行われます。

   • MongoDB の収益レポートを含む PDF をロードします。

   • チャンクサイズ（文字数）とチャンクのオーバーラップ（連続するチャンク間で重なり合う文字数）を指定して、データをチャンクに分割します。

   from langchain_community.document_loaders import PyPDFLoader
   from langchain.text_splitter import RecursiveCharacterTextSplitter
   # Load the PDF
   loader = PyPDFLoader("https://investors.mongodb.com/node/12236/pdf")
   data = loader.load()
   # Split the data into chunks
   text_splitter = RecursiveCharacterTextSplitter(chunk_size=400, chunk_overlap=20)
   documents = text_splitter.split_documents(data)

3. データをベクトル埋め込みに変換します。

   このコードを実行して、対応するベクトルが埋め込まれたドキュメントのリストを作成し、チャンク化されたドキュメントを取り込む準備をします。これらの埋め込みは、先ほど定義した get_embedding 関数を使用して生成します。

   # Prepare documents for insertion
   docs_to_insert = [{
       "text": doc.page_content,
       "embedding": get_embedding(doc.page_content)
   } for doc in documents]

4. データと埋め込みを Atlas に保存する

   次のコードを実行して、埋め込みを含むドキュメントを Atlas クラスターの rag_db.test コレクションに挿入します。コードを実行する前に、 <connection-string> を Atlas 接続文字列に置き換えます。

   from pymongo import MongoClient
   # Connect to your Atlas cluster
   client = MongoClient("<connection-string>")
   collection = client["rag_db"]["test"]
   # Insert documents into the collection
   result = collection.insert_many(docs_to_insert)

   Tip

   コードの実行後、クラスター内の rag_db.test コレクションに移動すると、Atlas UI でベクトル埋め込みを表示できます。

Atlas Vector Search を使用してドキュメントを検索します。

このセクションでは、Atlas Vector Search を使用して検索システムを作成し、ベクトルデータベースから関連するドキュメントを取得します。ノートブックに次の各コード スニペットを貼り付けて実行します。

1. ベクトル埋め込みに Atlas Vector Search インデックスを作成します。

   PyMongo ドライバーを使用してアプリケーションから直接インデックスを作成するには、次のコードを実行します。このコードには、インデックスが使用可能かどうかを確認するポーリング メカニズムも含まれています。

   詳細については、「ベクトル検索のフィールドにインデックスを作成する方法 」を参照してください。

   from pymongo.operations import SearchIndexModel
   import time
   # Create your index model, then create the search index
   index_name="vector_index"
   search_index_model = SearchIndexModel(
     definition = {
       "fields": [
         {
           "type": "vector",
           "numDimensions": 768,
           "path": "embedding",
           "similarity": "cosine"
         }
       ]
     },
     name = index_name,
     type = "vectorSearch"
   )
   collection.create_search_index(model=search_index_model)
   # Wait for initial sync to complete
   print("Polling to check if the index is ready. This may take up to a minute.")
   predicate=None
   if predicate is None:
      predicate = lambda index: index.get("queryable") is True
   while True:
      indices = list(collection.list_search_indexes(index_name))
      if len(indices) and predicate(indices[0]):
         break
      time.sleep(5)
   print(index_name + " is ready for querying.")

2. ベクトル検索クエリを実行するための関数を定義します。

   このコードを実行して、基本的なベクトル検索クエリを実行する get_query_results という検索関数を作成します。get_embedding 関数を使用して、検索クエリから埋め込みを作成します。次に、クエリを実行して、セマンティックに類似したドキュメントを返します。

   詳細については、「ベクター検索クエリの実行」を参照してください。

   # Define a function to run vector search queries
   def get_query_results(query):
     """Gets results from a vector search query."""
     query_embedding = get_embedding(query)
     pipeline = [
         {
               "$vectorSearch": {
                 "index": "vector_index",
                 "queryVector": query_embedding,
                 "path": "embedding",
                 "exact": True,
                 "limit": 5
               }
         }, {
               "$project": {
                 "_id": 0,
                 "text": 1
            }
         }
     ]
     results = collection.aggregate(pipeline)
     array_of_results = []
     for doc in results:
         array_of_results.append(doc)
     return array_of_results
   # Test the function with a sample query
   import pprint
   pprint.pprint(get_query_results("AI technology"))

   出力を表示

   [{'text': 'more of our customers. We also see a tremendous opportunity to win '
             'more legacy workloads, as AI has now become a catalyst to modernize '
             'these\n'
             "applications. MongoDB's  document-based architecture is "
             'particularly well-suited for the variety and scale of data required '
             'by AI-powered applications.'},
    {'text': 'artificial intelligence, in our offerings or partnerships; the '
             'growth and expansion of the market for database products and our '
             'ability to penetrate that\n'
             'market; our ability to integrate acquired businesses and '
             'technologies successfully or achieve the expected benefits of such '
             'acquisitions; our ability to'},
    {'text': 'MongoDB  continues to expand its AI ecosystem with the announcement '
             'of the MongoDB AI Applications Program (MAAP),'},
    {'text': 'which provides customers with reference architectures, pre-built '
             'partner integrations, and professional services to help\n'
             'them quickly build AI-powered applications. Accenture will '
             'establish a center of excellence focused on MongoDB  projects,\n'
             'and is the first global systems integrator to join MAAP.'},
    {'text': 'Bendigo and Adelaide Bank partnered with MongoDB  to modernize '
             'their core banking technology. With the help of\n'
             'MongoDB Relational Migrator and generative AI-powered modernization '
             'tools, Bendigo and Adelaide Bank decomposed an\n'
             'outdated consumer-servicing application into microservices and '
             'migrated off its underlying legacy relational database'}]

LLM を使用して応答を生成します。

このセクションでは、検索されたドキュメントをコンテキストとして使用するよう LLM に指示して応答を生成します。

次のコードの <token> を Hugging Face アクセス トークンに置き換え、ノートブックでコードを実行します。このコードは、次の処理を行います。

• 定義した get_query_results 関数を使用して、Atlas から関連するドキュメントを検索します。

• ユーザーの質問と検索されたドキュメントをコンテキストとして、プロンプトを作成します。

• Misttal7 B 指示 にアクセスする からのモデル化

• LLM に MongoDB の最新の AI に関する発表を支持します。生成される応答は異なる場合があります。

import os
from huggingface_hub import InferenceClient
# Specify search query, retrieve relevant documents, and convert to string
query = "What are MongoDB's latest AI announcements?"
context_docs = get_query_results(query)
context_string = " ".join([doc["text"] for doc in context_docs])
# Construct prompt for the LLM using the retrieved documents as the context
prompt = f"""Use the following pieces of context to answer the question at the end.
    {context_string}
    Question: {query}
"""
# Authenticate to Hugging Face and access the model
os.environ["HF_TOKEN"] = "<token>"
llm = InferenceClient(
    "mistralai/Mistral-7B-Instruct-v0.3",
    token = os.getenv("HF_TOKEN"))
# Prompt the LLM (this code varies depending on the model you use)
output = llm.chat_completion(
    messages=[{"role": "user", "content": prompt}],
    max_tokens=150
)
print(output.choices[0].message.content)

MongoDB's latest AI announcements include the
MongoDB AI Applications Program (MAAP), a program designed
to help customers build AI-powered applications more efficiently.
Additionally, they have announced significant performance
improvements in MongoDB 8.0, featuring faster reads, updates,
bulk inserts, and time series queries. Another announcement is the
general availability of Atlas Stream Processing to build sophisticated,
event-driven applications with real-time data.