# Tìm kiếm tài liệu Cửa hàng Vector theo sự tương đồng ngữ nghĩa {% openapi src="" path="/vector-stores/{vector-store-id}/documents/search" method="get" %} [rememberizer\_openapi.yml](https://4187618229-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fwbxu0T4faQnPtKbPzrD5%2Fuploads%2Fgit-blob-77b6137eeb641262ec8e531c78123c02b825b865%2Frememberizer_openapi.yml?alt=media\&token=b77a395b-ed7b-4546-9ec7-182d4939fd1b) {% endopenapi %} ## Ví dụ Yêu cầu {% tabs %} {% tab title="cURL" %} ```bash curl -X GET \ "https://api.rememberizer.ai/api/v1/vector-stores/vs_abc123/documents/search?q=How%20to%20integrate%20our%20product%20with%20third-party%20systems&n=5&prev_chunks=1&next_chunks=1" \ -H "x-api-key: YOUR_API_KEY" ``` {% hint style="info" %} Thay thế `YOUR_API_KEY` bằng khóa API Vector Store thực tế của bạn và `vs_abc123` bằng ID Vector Store của bạn. {% endhint %} {% endtab %} {% tab title="JavaScript" %} ```javascript const searchVectorStore = async (vectorStoreId, query, numResults = 5, prevChunks = 1, nextChunks = 1) => { const url = new URL(`https://api.rememberizer.ai/api/v1/vector-stores/${vectorStoreId}/documents/search`); url.searchParams.append('q', query); url.searchParams.append('n', numResults); url.searchParams.append('prev_chunks', prevChunks); url.searchParams.append('next_chunks', nextChunks); const response = await fetch(url.toString(), { method: 'GET', headers: { 'x-api-key': 'YOUR_API_KEY' } }); const data = await response.json(); console.log(data); }; searchVectorStore( 'vs_abc123', 'How to integrate our product with third-party systems', 5, 1, 1 ); ``` {% hint style="info" %} Thay thế `YOUR_API_KEY` bằng khóa API Vector Store thực tế của bạn và `vs_abc123` bằng ID Vector Store của bạn. {% endhint %} {% endtab %} {% tab title="Python" %} ```python import requests def search_vector_store(vector_store_id, query, num_results=5, prev_chunks=1, next_chunks=1): headers = { "x-api-key": "YOUR_API_KEY" } params = { "q": query, "n": num_results, "prev_chunks": prev_chunks, "next_chunks": next_chunks } response = requests.get( f"https://api.rememberizer.ai/api/v1/vector-stores/{vector_store_id}/documents/search", headers=headers, params=params ) data = response.json() print(data) search_vector_store( 'vs_abc123', 'How to integrate our product with third-party systems', 5, 1, 1 ) ``` {% hint style="info" %} Thay thế `YOUR_API_KEY` bằng khóa API Vector Store thực tế của bạn và `vs_abc123` bằng ID Vector Store của bạn. {% endhint %} {% endtab %} {% tab title="Ruby" %} ```ruby require 'net/http' require 'uri' require 'json' def search_vector_store(vector_store_id, query, num_results=5, prev_chunks=1, next_chunks=1) uri = URI("https://api.rememberizer.ai/api/v1/vector-stores/#{vector_store_id}/documents/search") params = { q: query, n: num_results, prev_chunks: prev_chunks, next_chunks: next_chunks } uri.query = URI.encode_www_form(params) request = Net::HTTP::Get.new(uri) request['x-api-key'] = 'YOUR_API_KEY' http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = true response = http.request(request) data = JSON.parse(response.body) puts data end search_vector_store( 'vs_abc123', 'How to integrate our product with third-party systems', 5, 1, 1 ) ``` {% hint style="info" %} Thay thế `YOUR_API_KEY` bằng khóa API Vector Store thực tế của bạn và `vs_abc123` bằng ID Vector Store của bạn. {% endhint %} {% endtab %} {% endtabs %} ## Tham số Đường dẫn | Tham số | Loại | Mô tả | | --------------- | ----- | ------------------------------------------------- | | vector-store-id | chuỗi | **Bắt buộc.** ID của cửa hàng vector để tìm kiếm. | ## Tham số truy vấn | Tham số | Loại | Mô tả | | ------------ | --------- | ------------------------------------------------------ | | q | chuỗi | **Bắt buộc.** Văn bản truy vấn tìm kiếm. | | n | số nguyên | Số lượng kết quả trả về. Mặc định: 10. | | t | số | Ngưỡng khớp. Mặc định: 0.7. | | prev\_chunks | số nguyên | Số lượng khối trước khối khớp để bao gồm. Mặc định: 0. | | next\_chunks | số nguyên | Số lượng khối sau khối khớp để bao gồm. Mặc định: 0. | ## Định dạng Phản hồi ```json { "vector_store": { "id": "vs_abc123", "name": "Tài liệu Sản phẩm" }, "matched_chunks": [ { "document": { "id": 1234, "name": "Hướng dẫn Tích hợp.pdf", "type": "application/pdf", "size": 250000, "indexed_on": "2023-06-15T10:30:00Z", "vector_store": "vs_abc123", "created": "2023-06-15T10:15:00Z", "modified": "2023-06-15T10:30:00Z" }, "matched_content": "Sản phẩm của chúng tôi cung cấp nhiều tùy chọn tích hợp cho các hệ thống bên thứ ba. Phương pháp chính là thông qua API RESTful của chúng tôi, hỗ trợ xác thực OAuth2. Ngoài ra, bạn có thể sử dụng SDK của chúng tôi có sẵn trong Python, JavaScript và Java.", "distance": 0.123 }, // ... nhiều đoạn khớp hơn ] } ``` ## Xác thực Điểm cuối này yêu cầu xác thực bằng cách sử dụng khóa API trong tiêu đề `x-api-key`. ## Phản hồi Lỗi | Mã Trạng Thái | Mô Tả | | ------------- | ------------------------------------------------------------------------- | | 400 | Yêu Cầu Không Hợp Lệ - Thiếu tham số bắt buộc hoặc định dạng không hợp lệ | | 401 | Không Được Phép - Khóa API không hợp lệ hoặc bị thiếu | | 404 | Không Tìm Thấy - Không tìm thấy Vector Store | | 500 | Lỗi Máy Chủ Nội Bộ | ## Mẹo Tối Ưu Hóa Tìm Kiếm ### Cửa Sổ Ngữ Cảnh Sử dụng các tham số `prev_chunks` và `next_chunks` để kiểm soát lượng ngữ cảnh được bao gồm với mỗi kết quả: * Đặt cả hai thành 0 để có các kết quả chính xác mà không có ngữ cảnh * Đặt cả hai thành 1-2 để có các kết quả với ngữ cảnh tối thiểu * Đặt cả hai thành 3-5 để có các kết quả với ngữ cảnh đáng kể ### Ngưỡng Khớp Tham số `t` điều khiển mức độ nghiêm ngặt của việc lọc các kết quả khớp: * Giá trị cao hơn (ví dụ: 0.9) chỉ trả về các kết quả khớp rất gần * Giá trị thấp hơn (ví dụ: 0.5) trả về nhiều kết quả khớp với sự đa dạng lớn hơn * Mặc định (0.7) cung cấp một cách tiếp cận cân bằng ## Các hoạt động theo lô Đối với các ứng dụng có lưu lượng cao, Rememberizer hỗ trợ các hoạt động theo lô hiệu quả trên các kho vector. Những phương pháp này tối ưu hóa hiệu suất khi xử lý nhiều truy vấn tìm kiếm. ### Triển Khai Tìm Kiếm Theo Lô {% tabs %} {% tab title="Python" %} ```python import requests import time import concurrent.futures def batch_search_vector_store(vector_store_id, queries, num_results=5, batch_size=10): """ Thực hiện tìm kiếm theo lô trên một kho vector Args: vector_store_id: ID của kho vector để tìm kiếm queries: Danh sách các chuỗi truy vấn tìm kiếm num_results: Số lượng kết quả cho mỗi truy vấn batch_size: Số lượng yêu cầu song song Returns: Danh sách các kết quả tìm kiếm """ headers = { "x-api-key": "YOUR_API_KEY" } results = [] # Xử lý theo lô để tránh làm quá tải API for i in range(0, len(queries), batch_size): batch_queries = queries[i:i+batch_size] with concurrent.futures.ThreadPoolExecutor(max_workers=batch_size) as executor: futures = [] for query in batch_queries: params = { "q": query, "n": num_results, "prev_chunks": 1, "next_chunks": 1 } # Gửi yêu cầu đến nhóm luồng future = executor.submit( requests.get, f"https://api.rememberizer.ai/api/v1/vector-stores/{vector_store_id}/documents/search", headers=headers, params=params ) futures.append(future) # Thu thập kết quả từ tất cả các tương lai for future in futures: response = future.result() if response.status_code == 200: results.append(response.json()) else: results.append({"error": f"Thất bại với mã trạng thái: {response.status_code}"}) # Thêm độ trễ giữa các lô để tránh giới hạn tần suất if i + batch_size < len(queries): time.sleep(1) return results # Ví dụ sử dụng queries = [ "Tích hợp với REST APIs", "Giao thức xác thực", "Cách triển khai lên môi trường sản xuất", "Kỹ thuật tối ưu hóa hiệu suất", "Thực hành tốt nhất về xử lý lỗi" ] search_results = batch_search_vector_store("vs_abc123", queries, num_results=3, batch_size=5) ``` {% endtab %} {% tab title="JavaScript" %} ```javascript /** * Thực hiện tìm kiếm theo lô trên một kho vector * * @param {string} vectorStoreId - ID của kho vector * @param {string[]} queries - Danh sách các truy vấn tìm kiếm * @param {Object} options - Tùy chọn cấu hình * @returns {Promise} - Danh sách kết quả tìm kiếm */ async function batchSearchVectorStore(vectorStoreId, queries, options = {}) { const { numResults = 5, batchSize = 10, delayBetweenBatches = 1000, prevChunks = 1, nextChunks = 1, distanceThreshold = 0.7 } = options; const results = []; const apiKey = 'YOUR_API_KEY'; // Xử lý theo lô để quản lý tải API for (let i = 0; i < queries.length; i += batchSize) { const batchQueries = queries.slice(i, i + batchSize); // Tạo mảng promise cho các yêu cầu song song const batchPromises = batchQueries.map(query => { const url = new URL(`https://api.rememberizer.ai/api/v1/vector-stores/${vectorStoreId}/documents/search`); url.searchParams.append('q', query); url.searchParams.append('n', numResults); url.searchParams.append('prev_chunks', prevChunks); url.searchParams.append('next_chunks', nextChunks); url.searchParams.append('t', distanceThreshold); return fetch(url.toString(), { method: 'GET', headers: { 'x-api-key': apiKey } }) .then(response => { if (response.ok) { return response.json(); } else { return { error: `Thất bại với trạng thái: ${response.status}` }; } }) .catch(error => { return { error: error.message }; }); }); // Chờ tất cả các yêu cầu trong lô hoàn thành const batchResults = await Promise.all(batchPromises); results.push(...batchResults); // Thêm độ trễ giữa các lô để tránh giới hạn tốc độ if (i + batchSize < queries.length) { await new Promise(resolve => setTimeout(resolve, delayBetweenBatches)); } } return results; } // Ví dụ sử dụng const queries = [ "Tích hợp với REST APIs", "Giao thức xác thực", "Cách triển khai lên môi trường sản xuất", "Kỹ thuật tối ưu hóa hiệu suất", "Thực hành tốt nhất về xử lý lỗi" ]; const options = { numResults: 3, batchSize: 5, delayBetweenBatches: 1000, prevChunks: 1, nextChunks: 1 }; batchSearchVectorStore("vs_abc123", queries, options) .then(results => console.log(results)) .catch(error => console.error("Tìm kiếm theo lô thất bại:", error)); ``` {% endtab %} {% tab title="Ruby" %} ```ruby require 'net/http' require 'uri' require 'json' require 'concurrent' # Thực hiện tìm kiếm theo lô trên một kho vector # # @param vector_store_id [String] ID của cửa hàng vector # @param queries [Array] Danh sách các truy vấn tìm kiếm # @param num_results [Integer] Số lượng kết quả cho mỗi truy vấn # @param batch_size [Integer] Số lượng yêu cầu song song # @param delay_between_batches [Float] Số giây để chờ giữa các lô # @return [Array] Kết quả tìm kiếm cho mỗi truy vấn def batch_search_vector_store(vector_store_id, queries, num_results: 5, batch_size: 10, delay_between_batches: 1.0) results = [] api_key = 'YOUR_API_KEY' # Xử lý theo lô queries.each_slice(batch_size).with_index do |batch_queries, batch_index| # Tạo một nhóm luồng cho việc thực thi đồng thời pool = Concurrent::FixedThreadPool.new(batch_size) futures = [] batch_queries.each do |query| # Gửi mỗi yêu cầu đến nhóm luồng futures << Concurrent::Future.execute(executor: pool) do uri = URI("https://api.rememberizer.ai/api/v1/vector-stores/#{vector_store_id}/documents/search") params = { q: query, n: num_results, prev_chunks: 1, next_chunks: 1 } uri.query = URI.encode_www_form(params) request = Net::HTTP::Get.new(uri) request['x-api-key'] = api_key http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = true begin response = http.request(request) if response.code.to_i == 200 JSON.parse(response.body) else { "error" => "Thất bại với mã trạng thái: #{response.code}" } end rescue => e { "error" => e.message } end end end # Thu thập kết quả từ tất cả các tương lai batch_results = futures.map(&:value) results.concat(batch_results) # Thêm độ trễ giữa các lô if batch_index < (queries.length / batch_size.to_f).ceil - 1 sleep(delay_between_batches) end end pool.shutdown results end # Ví dụ sử dụng queries = [ "Tích hợp với REST APIs", "Giao thức xác thực", "Cách triển khai lên môi trường sản xuất", "Kỹ thuật tối ưu hóa hiệu suất", "Thực hành tốt nhất trong xử lý lỗi" ] results = batch_search_vector_store( "vs_abc123", queries, num_results: 3, batch_size: 5 ) puts results ``` {% endtab %} {% endtabs %} ### Tối ưu hóa hiệu suất cho các thao tác theo lô Khi triển khai các thao tác theo lô cho việc tìm kiếm trong kho vector, hãy xem xét những thực tiễn tốt nhất sau: 1. **Kích thước lô tối ưu**: Đối với hầu hết các ứng dụng, xử lý 5-10 truy vấn song song cung cấp sự cân bằng tốt giữa thông lượng và mức sử dụng tài nguyên. 2. **Nhận thức về giới hạn tốc độ**: Bao gồm các cơ chế trì hoãn giữa các lô (thường là 1-2 giây) để tránh chạm vào giới hạn tốc độ API. 3. **Xử lý lỗi**: Triển khai xử lý lỗi mạnh mẽ cho các truy vấn riêng lẻ có thể thất bại trong một lô. 4. **Quản lý kết nối**: Đối với các ứng dụng có khối lượng lớn, triển khai kết nối pooling để giảm thiểu chi phí. 5. **Cấu hình thời gian chờ**: Đặt thời gian chờ thích hợp cho mỗi yêu cầu để ngăn chặn các truy vấn chạy lâu làm tắc nghẽn toàn bộ lô. 6. **Xử lý kết quả**: Xem xét việc xử lý kết quả một cách không đồng bộ khi chúng trở nên khả dụng thay vì chờ đợi tất cả kết quả. 7. **Giám sát**: Theo dõi các chỉ số hiệu suất như thời gian phản hồi trung bình và tỷ lệ thành công để xác định cơ hội tối ưu hóa. Đối với các ứng dụng sản xuất có khối lượng truy vấn rất cao, hãy xem xét việc triển khai một hệ thống hàng đợi với các quy trình làm việc để quản lý các lô lớn một cách hiệu quả. Điểm cuối này cho phép bạn tìm kiếm kho vector của mình bằng cách sử dụng sự tương đồng ngữ nghĩa. Nó trả về các tài liệu có liên quan về mặt khái niệm đến truy vấn của bạn, ngay cả khi chúng không chứa các từ khóa chính xác. Điều này làm cho nó đặc biệt mạnh mẽ cho các truy vấn ngôn ngữ tự nhiên và trả lời câu hỏi.