Atlas 벡터 검색을 사용한 검색-증강 생성(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 연결 문자열과 Hugging Face 액세스 토큰을 저장할 .env 파일을 생성하세요.

   .env

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

   <access-token> 및 <connection-string> 자리 표시자 값을 Hugging Face 액세스 토큰과 Atlas 클러스터의 SRV 연결 문자열로 바꾸세요. 연결 문자열 은 다음 형식을 사용해야 합니다.

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

벡터 임베딩을 생성하는 함수를 만듭니다.

이 섹션에서는 다음을 수행하는 함수를 만듭니다.

• 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-query-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에 지시하여 응답을 생성합니다. 이 예시에서는 방금 정의한 함수를 사용하여 데이터베이스에서 일치하는 문서를 조회하고 추가로 검색합니다.

• Hugging Face의 모델 허브에서 Mistral 7B Instruct 모델에 액세스합니다.

• 사용자의 질문과 조회된 문서를 프롬프트에 포함하도록 LLM에 지시합니다.

• LLM에 MongoDB의 최신 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.

환경을 설정합니다.

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 연결 문자열과 Hugging Face 액세스 토큰을 저장할 .env 파일을 생성하세요.

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

   <access-token> 및 <connection-string> 자리 표시자 값을 Hugging Face 액세스 토큰과 Atlas 클러스터의 SRV 연결 문자열로 바꾸세요. 연결 문자열 은 다음 형식을 사용해야 합니다.

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

   참고

   최소 Node.js 버전 요구 사항

   Node.js v20.x --env-file 옵션을 도입했습니다. 이전 버전의 Node.js를 사용하는 경우 프로젝트에 dotenv 패키지를 추가하거나 다른 방법으로 환경 변수를 관리하세요.

벡터 임베딩을 생성하는 함수를 만듭니다.

이 섹션에서는 다음을 수행하는 함수를 만듭니다.

• Hugging Face의 모델 허브에서 nomic-embed-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에 데이터를 수집합니다.

이 섹션에서는 LLM이 액세스할 수 없는 샘플 데이터를 Atlas로 수집합니다. 다음 코드는 LangChain 통합 및 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에 지시하여 응답을 생성합니다. 이 예시에서는 방금 정의한 함수를 사용하여 데이터베이스에서 일치하는 문서를 조회하고 추가로 검색합니다.

• Hugging Face의 모델 허브에서 Mistral 7B Instruct 모델에 액세스합니다.

• 사용자의 질문과 조회된 문서를 프롬프트에 포함하도록 LLM에 지시합니다.

• LLM에 MongoDB의 최신 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 pymongo sentence_transformers einops langchain langchain_community pypdf huggingface_hub

Atlas에 데이터를 수집합니다.

이 섹션에서는 LLM 이 액세스 할 수 없는 샘플 데이터를 Atlas 로 수집 합니다. 다음 각 코드 스니펫을 노트북에 붙여넣고 실행 합니다.

1. 벡터 임베딩을 생성하는 함수를 정의합니다.

   이 코드를 실행하여 오픈 소스 임베딩 모델을 사용하여 벡터 임베딩을 생성하는 함수를 생성합니다. 구체적으로 이 코드는 다음을 수행합니다.

   • 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 cluster 의 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)

   팁

   코드를 실행 한 후 클러스터 의 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> 을 허깅 페이스 액세스 토큰으로 바꾼 다음, 노트북에서 코드를 실행 합니다. 이 코드는 다음을 수행합니다.

• 정의한 get_query_results 함수를 사용하여 Atlas 에서 관련 문서를 조회 합니다.

• 사용자의 질문과 조회된 문서를 컨텍스트로 사용하여 프롬프트를 생성합니다.

• Hugging Face의 모델 허브에서 Mistral 7B Instruct 모델에 액세스합니다.

• MongoDB의 최신 AI 발표에 대한 LLM 프롬프트를 표시합니다. 생성된 응답은 다를 수 있습니다.

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.