Søg efter Vektorbutik dokumenter efter semantisk lighed

Søg i Vector Store-dokumenter med semantisk lighed og batchoperationer

Error while loading OpenAPI operation — Failed to fetch OpenAPI file

Eksempelanmodninger

cURL

curl -X GET \
  "https://api.rememberizer.ai/api/v1/vector-stores/vs_abc123/documents/search?q=Hvordan%20integrerer%20vi%20vores%20produkt%20med%20tredjeparts%20systemer&n=5&prev_chunks=1&next_chunks=1" \
  -H "x-api-key: DIN_API_NØGLE"

Erstat DIN_API_NØGLE med din faktiske Vector Store API-nøgle og vs_abc123 med dit Vector Store ID.

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': 'DIN_API_NØGLE'
    }
  });
  
  const data = await response.json();
  console.log(data);
};

searchVectorStore(
  'vs_abc123',
  'Hvordan integrerer vi vores produkt med tredjeparts systemer',
  5,
  1,
  1
);

Erstat DIN_API_NØGLE med din faktiske Vector Store API-nøgle og vs_abc123 med dit Vector Store ID.

Python

import requests

def search_vector_store(vector_store_id, query, num_results=5, prev_chunks=1, next_chunks=1):
    headers = {
        "x-api-key": "DIN_API_NØGLE"
    }
    
    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',
    'Hvordan integrerer vi vores produkt med tredjeparts systemer',
    5,
    1,
    1
)

Erstat DIN_API_NØGLE med din faktiske Vector Store API-nøgle og vs_abc123 med dit Vector Store ID.

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'] = 'DIN_API_NØGLE'
  
  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',
  'Hvordan integrerer vi vores produkt med tredjeparts systemer',
  5,
  1,
  1
)

Erstat DIN_API_NØGLE med din faktiske Vector Store API-nøgle og vs_abc123 med dit Vector Store ID.

Sti Parametre

Parameter	Type	Beskrivelse
vector-store-id	string	Påkrævet. ID'et på vektorbutikken, der skal søges i.

Forespørgselsparametre

Parameter	Type	Beskrivelse
q	string	Påkrævet. Den søgeforespørgselstekst.
n	integer	Antal resultater der skal returneres. Standard: 10.
t	number	Matchende tærskel. Standard: 0.7.
prev_chunks	integer	Antal chunks før den matchede chunk der skal inkluderes. Standard: 0.
next_chunks	integer	Antal chunks efter den matchede chunk der skal inkluderes. Standard: 0.

Responsformat

{
  "vector_store": {
    "id": "vs_abc123",
    "name": "Produktdokumentation"
  },
  "matched_chunks": [
    {
      "document": {
        "id": 1234,
        "name": "Integrationsguide.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": "Vores produkt tilbyder flere integrationsmuligheder for tredjepartssystemer. Den primære metode er gennem vores RESTful API, som understøtter OAuth2-godkendelse. Derudover kan du bruge vores SDK, der er tilgængelig i Python, JavaScript og Java.",
      "distance": 0.123
    },
    // ... flere matchede dele
  ]
}

Godkendelse

Denne endpoint kræver godkendelse ved hjælp af en API-nøgle i x-api-key headeren.

Fejlrespons

Statuskode	Beskrivelse
400	Dårlig anmodning - Manglende nødvendige parametre eller ugyldigt format
401	Uautoriseret - Ugyldig eller manglende API-nøgle
404	Ikke fundet - Vektorbutik ikke fundet
500	Intern serverfejl

Søgeoptimeringstips

Kontekstvinduer

Brug prev_chunks og next_chunks parametrene til at styre, hvor meget kontekst der inkluderes med hver match:

• Sæt begge til 0 for præcise matches uden kontekst

• Sæt begge til 1-2 for matches med minimal kontekst

• Sæt begge til 3-5 for matches med betydelig kontekst

Matchende Tærskel

t parameteret styrer, hvor strengt matches filtreres:

• Højere værdier (f.eks. 0.9) returnerer kun meget tætte matches

• Lavere værdier (f.eks. 0.5) returnerer flere matches med større variation

• Standardværdien (0.7) giver en afbalanceret tilgang

Batch Operationer

For applikationer med høj gennemstrømning understøtter Rememberizer effektive batchoperationer på vektorbutikker. Disse metoder optimerer ydeevnen, når der behandles flere søgeforespørgsler.

Batch Search Implementation

Python

import requests
import time
import concurrent.futures

def batch_search_vector_store(vector_store_id, queries, num_results=5, batch_size=10):
    """
    Udfør batch-søgninger mod et vektorlager
    
    Args:
        vector_store_id: ID på det vektorlager, der skal søges i
        queries: Liste over søgestrenge
        num_results: Antal resultater pr. søgning
        batch_size: Antal parallelle anmodninger
        
    Returns:
        Liste over søgeresultater
    """
    headers = {
        "x-api-key": "YOUR_API_KEY"
    }
    
    results = []
    
    # Behandl i batches for at undgå at overbelaste API'et
    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
                }
                
                # Indsend anmodningen til trådpoolen
                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)
            
            # Indsaml resultater fra alle futures
            for future in futures:
                response = future.result()
                if response.status_code == 200:
                    results.append(response.json())
                else:
                    results.append({"error": f"Fejl med statuskode: {response.status_code}"})
        
        # Tilføj en forsinkelse mellem batches for at undgå hastighedsbegrænsning
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

# Eksempel på brug
forespørgsler = [
    "Integration med REST API'er",
    "Godkendelsesprotokoller",
    "Hvordan man implementerer i produktion",
    "Ydelsesoptimeringsteknikker",
    "Bedste praksis for fejlhåndtering"
]

søgeresultater = batch_search_vector_store("vs_abc123", forespørgsler, num_results=3, batch_size=5)

JavaScript

/**
 * Udfør batch-søgninger mod et vektorlager
 * 
 * @param {string} vectorStoreId - ID for vektorlageret
 * @param {string[]} queries - Liste over søgeforespørgsler
 * @param {Object} options - Konfigurationsmuligheder
 * @returns {Promise<Array>} - Liste over søgeresultater
 */
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';
  
  // Behandl i batches for at håndtere API-belastning
  for (let i = 0; i < queries.length; i += batchSize) {
    const batchQueries = queries.slice(i, i + batchSize);
    
    // Opret løfte-array til parallelle anmodninger
    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: `Mislykkedes med status: ${response.status}` };
        }
      })
      .catch(error => {
        return { error: error.message };
      });
    });
    
    // Vent på, at alle anmodninger i batchen er færdige
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Tilføj forsinkelse mellem batches for at undgå hastighedsbegrænsning
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Eksempel på brug
const queries = [
  "Integration med REST API'er",
  "Godkendelsesprotokoller",
  "Hvordan man implementerer i produktion",
  "Ydelsesoptimeringsteknikker",
  "Bedste praksis for fejlhåndtering"
];

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("Batch-søgning mislykkedes:", error));

Ruby

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

# Udfør batch-søgninger mod et vektorbutik
#
# @param vector_store_id [String] ID på vektorbutikken
# @param queries [Array<String>] Liste over søgeforespørgsler
# @param num_results [Integer] Antal resultater pr. forespørgsel
# @param batch_size [Integer] Antal parallelle anmodninger
# @param delay_between_batches [Float] Sekunder at vente mellem batcher
# @return [Array] Søgeresultater for hver forespørgsel
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'
  
  # Behandl i batcher
  queries.each_slice(batch_size).with_index do |batch_queries, batch_index|
    # Opret en trådpool til samtidig udførelse
    pool = Concurrent::FixedThreadPool.new(batch_size)
    futures = []
    
    batch_queries.each do |query|
      # Indsend hver anmodning til trådpoolen
      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" => "Mislykkedes med statuskode: #{response.code}" }
          end
        rescue => e
          { "error" => e.message }
        end
      end
    end
    
    # Saml resultater fra alle futures
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Tilføj forsinkelse mellem batcher
    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 = [
  "Integration med REST API'er",
  "Godkendelsesprotokoller",
  "Hvordan man implementerer i produktion", 
  "Ydelsesoptimeringsteknikker",
  "Bedste praksis for fejlhåndtering"
]

resultater = batch_search_vector_store(
  "vs_abc123", 
  forespørgsler, 
  num_results: 3, 
  batch_size: 5
)

puts resultater

Ydelsesoptimering for Batch-operationer

Når du implementerer batch-operationer til søgninger i vektorbutikker, skal du overveje disse bedste praksisser:

1. Optimal Batch-størrelse: For de fleste applikationer giver behandling af 5-10 forespørgsler parallelt en god balance mellem gennemløb og ressourceforbrug.

2. Bevidsthed om Ratebegrænsning: Inkluder forsinkelsesmekanismer mellem batches (typisk 1-2 sekunder) for at undgå at ramme API'ens ratebegrænsninger.

3. Fejlhåndtering: Implementer robust fejlhåndtering for individuelle forespørgsler, der måtte fejle inden for en batch.

4. Forbindelsesstyring: For applikationer med høj volumen, implementer forbindelsespulje for at reducere overhead.

5. Timeout-konfiguration: Sæt passende timeouts for hver anmodning for at forhindre, at langvarige forespørgsler blokerer hele batchen.

6. Resultatbehandling: Overvej at behandle resultater asynkront, efterhånden som de bliver tilgængelige, i stedet for at vente på alle resultater.

7. Overvågning: Spor ydelsesmetrikker som gennemsnitlig svartid og succesrater for at identificere optimeringsmuligheder.

For produktionsapplikationer med meget høje forespørgselsvolumener, overvej at implementere et køsystem med arbejdere for effektivt at håndtere store batches.

Denne endpoint giver dig mulighed for at søge i din vektorbutik ved hjælp af semantisk lighed. Den returnerer dokumenter, der er konceptuelt relateret til din forespørgsel, selvom de ikke indeholder de nøjagtige nøgleord. Dette gør det særligt kraftfuldt til naturlige sprogforespørgsler og spørgsmålssvar.