Tìm kiếm tài liệu Cửa hàng Vector theo sự tương đồng ngữ nghĩa

Tìm kiếm tài liệu Vector Store với sự tương đồng ngữ nghĩa và các thao tác theo lô

get

Initiate a search operation with a query text and receive most semantically similar responses from the vector store.

Path parameters

vector-store-idstringRequired

The ID of the vector store.

Query parameters

qstringRequired

The search query text.

nintegerOptional

Number of chunks to return.

tnumberOptional

Matching threshold.

prev_chunksintegerOptional

Number of chunks before the matched chunk to include.

next_chunksintegerOptional

Number of chunks after the matched chunk to include.

Header parameters

x-api-keystringRequired

The API key for authentication.

Responses

200

Search results retrieved successfully.

application/json

get

/vector-stores/{vector-store-id}/documents/search

GET /api/v1/vector-stores/{vector-store-id}/documents/search?q=text HTTP/1.1
Host: api.rememberizer.ai
x-api-key: text
Accept: */*

200

Search results retrieved successfully.

{
  "vector_store": {
    "id": "text",
    "name": "text"
  },
  "matched_chunks": [
    {
      "document": {
        "id": 1,
        "name": "text",
        "type": "text",
        "size": 1,
        "indexed_on": "2026-01-05T01:46:44.360Z",
        "vector_store": "text",
        "created": "2026-01-05T01:46:44.360Z",
        "modified": "2026-01-05T01:46:44.360Z"
      },
      "matched_content": "text",
      "distance": 1
    }
  ]
}

Ví dụ Yêu cầu

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"

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.

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
);

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.

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
)

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.

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
)

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.

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ả

chuỗi

Bắt buộc. Văn bản truy vấn tìm kiếm.

số nguyên

Số lượng kết quả trả về. Mặc định: 10.

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

{
  "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ô

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)

/**
 * 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<Array>} - 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));

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<String>] 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

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:

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.
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.
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ô.
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í.
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ô.
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ả.
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.

PreviousXóa một tài liệu trong Cửa hàng Vector NextCập nhật nội dung tệp trong Cửa hàng Vector

Last updated 17 days ago

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)

/** * 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<Array>} - 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));

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<String>] 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