Søg efter dokumenter efter semantisk lighed

Semantisk søgeendpoint med batchbehandlingsmuligheder

Eksempelanmodninger

curl -X GET \
  "https://api.rememberizer.ai/api/v1/documents/search/?q=Hvordan%20integrerer%20man%20Rememberizer%20med%20tilpassede%20applikationer&n=5&from=2023-01-01T00:00:00Z&to=2023-12-31T23:59:59Z" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

Erstat YOUR_JWT_TOKEN med din faktiske JWT-token.

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

Erstat YOUR_JWT_TOKEN med din faktiske JWT-token.

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)

Erstat YOUR_JWT_TOKEN med din faktiske JWT-token.

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)

Erstat YOUR_JWT_TOKEN med din faktiske JWT-token.

Forespørgselsparametre

Parameter

Type

Beskrivelse

string

Påkrævet. Den søgeforespørgselstekst (op til 400 ord).

integer

Antal resultater der skal returneres. Standard: 3. Brug højere værdier (f.eks. 10) for mere omfattende resultater.

from

string

Starten af tidsintervallet for dokumenter der skal søges, i ISO 8601 format.

string

Slutningen af tidsintervallet for dokumenter der skal søges, i ISO 8601 format.

prev_chunks

integer

Antal forudgående chunks der skal inkluderes for kontekst. Standard: 2.

next_chunks

integer

Antal følgende chunks der skal inkluderes for kontekst. Standard: 2.

Svarformat

{
  "data_sources": [
    {
      "name": "Google Drive",
      "documents": 3
    },
    {
      "name": "Slack",
      "documents": 2
    }
  ],
  "matched_chunks": [
    {
      "document": {
        "id": 12345,
        "document_id": "1aBcD2efGhIjK3lMnOpQrStUvWxYz",
        "name": "Rememberizer API Dokumentation.pdf",
        "type": "application/pdf",
        "path": "/Documents/Rememberizer/API Dokumentation.pdf",
        "url": "https://drive.google.com/file/d/1aBcD2efGhIjK3lMnOpQrStUvWxYz/view",
        "size": 250000,
        "created_time": "2023-05-10T14:30:00Z",
        "modified_time": "2023-06-15T09:45:00Z",
        "indexed_on": "2023-06-15T10:30:00Z",
        "integration": {
          "id": 101,
          "integration_type": "google_drive"
        }
      },
      "matched_content": "For at integrere Rememberizer med brugerdefinerede applikationer kan du bruge OAuth2-godkendelsesflowet til at autorisere din applikation til at få adgang til en brugers Rememberizer-data. Når du er autoriseret, kan din applikation bruge Rememberizer API'erne til at søge efter dokumenter, hente indhold og mere.",
      "distance": 0.123
    },
    // ... flere matchede dele
  ],
  "message": "Søgningen blev gennemført med succes",
  "code": "success"
}

Søgeoptimeringstips

Til Spørgsmål Svar

Når du søger efter et svar på et spørgsmål, så prøv at formulere din forespørgsel, som om det var et ideelt svar. For eksempel:

I stedet for: "Hvad er vektorindlejring?" Prøv: "Vektorindlejring er en teknik, der konverterer tekst til numeriske vektorer i et højdimensionelt rum."

For en dybere forståelse af, hvordan vektorindlejringer fungerer, og hvorfor denne søgemetode er effektiv, se Hvad er Vektorindlejringer og Vektor Databaser?

Justering af Resultatantal

Start med n=3 for hurtige, høj-relevante resultater
Øg til n=10 eller højere for mere omfattende information
Hvis søgningen returnerer utilstrækkelig information, prøv at øge n-parameteren

Tidsbaseret filtrering

Brug from og to parametrene til at fokusere på dokumenter fra specifikke tidsperioder:

Nylige dokumenter: Sæt from til en nylig dato
Historisk analyse: Angiv et specifikt datointerval
Udelukke forældet information: Sæt en passende to dato

Batchoperationer

For effektivt at håndtere store mængder af søgeforespørgsler understøtter Rememberizer batchoperationer for at optimere ydeevnen og reducere API-opkaldsoverskuddet.

Batch Søgning

import requests
import time
import json
from concurrent.futures import ThreadPoolExecutor

def batch_search_documents(queries, num_results=5, batch_size=10):
    """
    Udfør batch søgninger med flere forespørgsler
    
    Args:
        queries: Liste af søgeforespørgselsstrenge
        num_results: Antal resultater der skal returneres pr. forespørgsel
        batch_size: Antal forespørgsler der skal behandles parallelt
    
    Returns:
        Liste af søgeresultater for hver forespørgsel
    """
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN",
        "Content-Type": "application/json"
    }
    
    results = []
    
    # Behandl forespørgsler i batches
    for i in range(0, len(queries), batch_size):
        batch = queries[i:i+batch_size]
        
        # Opret en trådpool for at sende forespørgsler parallelt
        with ThreadPoolExecutor(max_workers=batch_size) as executor:
            futures = []
            
            for query in batch:
                params = {
                    "q": query,
                    "n": num_results
                }
                
                future = executor.submit(
                    requests.get,
                    "https://api.rememberizer.ai/api/v1/documents/search/",
                    headers=headers,
                    params=params
                )
                futures.append(future)
            
            # Indsaml resultater efterhånden som de fuldføres
            for future in futures:
                response = future.result()
                results.append(response.json())
        
        # Rate limiting - pause mellem batches for at undgå API throttling
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

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

results = batch_search_documents(queries, num_results=3, batch_size=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

Ydelsesovervejelser

Når du implementerer batchoperationer, skal du overveje disse bedste praksisser:

Optimal Batchstørrelse: Start med batchstørrelser på 5-10 forespørgsler og juster baseret på din applikations ydelseskarakteristika.
Hastighedsbegrænsning: Inkluder forsinkelser mellem batcher for at forhindre API-throttling. Et godt udgangspunkt er 1 sekund mellem batcher.
Fejlhåndtering: Implementer robust fejlhåndtering for at håndtere mislykkede anmodninger inden for batcher.
Ressourcestyring: Overvåg klient-side ressourceforbrug, især med store batchstørrelser, for at forhindre overdreven hukommelsesforbrug.
Responsbehandling: Behandl batchresultater asynkront, når det er muligt, for at forbedre brugeroplevelsen.

For applikationer med høj volumen, overvej at implementere et køsystem for effektivt at håndtere et stort antal søgeanmodninger.

Denne endpoint giver kraftfulde semantiske søgefunktioner på tværs af din samlede vidensbase. Den bruger vektorindlejringer til at finde indhold baseret på betydning snarere end præcise nøgleordsmatch.

PreviousHent Slacks indhold NextVektorbutik API'er

Last updated 1 month ago

import requests import time import json from concurrent.futures import ThreadPoolExecutor def batch_search_documents(queries, num_results=5, batch_size=10): """ Udfør batch søgninger med flere forespørgsler Args: queries: Liste af søgeforespørgselsstrenge num_results: Antal resultater der skal returneres pr. forespørgsel batch_size: Antal forespørgsler der skal behandles parallelt Returns: Liste af søgeresultater for hver forespørgsel """ headers = { "Authorization": "Bearer YOUR_JWT_TOKEN", "Content-Type": "application/json" } results = [] # Behandl forespørgsler i batches for i in range(0, len(queries), batch_size): batch = queries[i:i+batch_size] # Opret en trådpool for at sende forespørgsler parallelt with ThreadPoolExecutor(max_workers=batch_size) as executor: futures = [] for query in batch: params = { "q": query, "n": num_results } future = executor.submit( requests.get, "https://api.rememberizer.ai/api/v1/documents/search/", headers=headers, params=params ) futures.append(future) # Indsaml resultater efterhånden som de fuldføres for future in futures: response = future.result() results.append(response.json()) # Rate limiting - pause mellem batches for at undgå API throttling if i + batch_size < len(queries): time.sleep(1) return results # Eksempel på brug queries = [ "Hvordan man bruger OAuth med Rememberizer", "Konfigurationsmuligheder for vektordatabaser", "Bedste praksis for semantisk søgning", # Tilføj flere forespørgsler efter behov ] results = batch_search_documents(queries, num_results=3, batch_size=5)

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