Søg efter dokumenter efter semantisk lighed

const searchDocuments = async (query, numResults = 5, from = null, to = null) => {
  const url = new URL('https://api.rememberizer.ai/api/v1/documents/search/');
  url.searchParams.append('q', query);
  url.searchParams.append('n', numResults);
  
  if (from) {
    url.searchParams.append('from', from);
  }
  
  if (to) {
    url.searchParams.append('to', to);
  }
  
  const response = await fetch(url.toString(), {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_JWT_TOKEN'
    }
  });
  
  const data = await response.json();
  console.log(data);
};

searchDocuments('Hvordan integrerer man Rememberizer med tilpassede applikationer', 5);

import requests

def search_documents(query, num_results=5, from_date=None, to_date=None):
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN"
    }
    
    params = {
        "q": query,
        "n": num_results
    }
    
    if from_date:
        params["from"] = from_date
    
    if to_date:
        params["to"] = to_date
    
    response = requests.get(
        "https://api.rememberizer.ai/api/v1/documents/search/",
        headers=headers,
        params=params
    )
    
    data = response.json()
    print(data)

search_documents("Hvordan integrerer man Rememberizer med tilpassede applikationer", 5)

require 'net/http'
require 'uri'
require 'json'

def search_documents(query, num_results=5, from_date=nil, to_date=nil)
  uri = URI('https://api.rememberizer.ai/api/v1/documents/search/')
  params = {
    q: query,
    n: num_results
  }
  
  params[:from] = from_date if from_date
  params[:to] = to_date if to_date
  
  uri.query = URI.encode_www_form(params)
  
  request = Net::HTTP::Get.new(uri)
  request['Authorization'] = 'Bearer YOUR_JWT_TOKEN'
  
  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_documents("Hvordan integrerer man Rememberizer med tilpassede applikationer", 5)

/**
 * Udfør batch-søgninger med flere forespørgsler
 * 
 * @param {string[]} queries - Liste over søgeforespørgsler
 * @param {number} numResults - Antal resultater der skal returneres pr. forespørgsel
 * @param {number} batchSize - Antal forespørgsler der skal behandles parallelt
 * @param {number} delayBetweenBatches - Millisekunder der skal ventes mellem batches
 * @returns {Promise<Array>} - Liste over søgeresultater for hver forespørgsel
 */
async function batchSearchDocuments(queries, numResults = 5, batchSize = 10, delayBetweenBatches = 1000) {
  const results = [];
  
  // Behandl forespørgsler i batches
  for (let i = 0; i < queries.length; i += batchSize) {
    const batch = queries.slice(i, i + batchSize);
    
    // Opret et array af promises for samtidige anmodninger
    const batchPromises = batch.map(query => {
      const url = new URL('https://api.rememberizer.ai/api/v1/documents/search/');
      url.searchParams.append('q', query);
      url.searchParams.append('n', numResults);
      
      return fetch(url.toString(), {
        method: 'GET',
        headers: {
          'Authorization': 'Bearer YOUR_JWT_TOKEN'
        }
      }).then(response => response.json());
    });
    
    // Vent på at alle anmodninger i batchen er færdige
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Rate limiting - pause mellem batches for at undgå API-throttling
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Eksempel på brug
const queries = [
  "Hvordan man bruger OAuth med Rememberizer",
  "Konfigurationsmuligheder for vektordatabaser",
  "Bedste praksis for semantisk søgning",
  // Tilføj flere forespørgsler efter behov
];

batchSearchDocuments(queries, 3, 5)
  .then(results => console.log(results))
  .catch(error => console.error('Fejl i batch-søgning:', error));

require 'net/http'
require 'uri'
require 'json'
require 'concurrent'

# Udfør batch-søgninger med flere forespørgsler
#
# @param queries [Array<String>] Liste over søgeforespørgselsstrenge
# @param num_results [Integer] Antal resultater, der skal returneres pr. forespørgsel
# @param batch_size [Integer] Antal forespørgsler, der skal behandles parallelt
# @param delay_between_batches [Float] Sekunder at vente mellem batcher
# @return [Array] Liste over søgeresultater for hver forespørgsel
def batch_search_documents(queries, num_results = 5, batch_size = 10, delay_between_batches = 1.0)
  results = []
  
  # Behandl forespørgsler i batch
  queries.each_slice(batch_size).with_index do |batch, batch_index|
    # Opret en trådpool til samtidige anmodninger
    pool = Concurrent::FixedThreadPool.new(batch_size)
    futures = []
    
    batch.each do |query|
      futures << Concurrent::Future.execute(executor: pool) do
        uri = URI('https://api.rememberizer.ai/api/v1/documents/search/')
        params = {
          q: query,
          n: num_results
        }
        
        uri.query = URI.encode_www_form(params)
        
        request = Net::HTTP::Get.new(uri)
        request['Authorization'] = 'Bearer YOUR_JWT_TOKEN'
        
        http = Net::HTTP.new(uri.host, uri.port)
        http.use_ssl = true
        
        response = http.request(request)
        JSON.parse(response.body)
      end
    end
    
    # Indsaml resultater fra alle tråde
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Hastighedsbegrænsning - pause mellem batches for at undgå API-throttling
    if batch_index < (queries.length / batch_size.to_f).ceil - 1
      sleep(delay_between_batches)
    end
  end
  
  pool.shutdown
  results
end

# Eksempel på brug
forespørgsler = [
  "Hvordan man bruger OAuth med Rememberizer",
  "Konfigurationsmuligheder for vektordatabaser",
  "Bedste praksis for semantisk søgning",
  # Tilføj flere forespørgsler efter behov
]

resultater = batch_search_documents(forespørgsler, 3, 5)
puts resultater