Nach Dokumenten im Vektor-Speicher anhand semantischer Ähnlichkeit suchen

Durchsuchen Sie Vector Store-Dokumente mit semantischer Ähnlichkeit und Batch-Operationen

Beispielanfragen

curl -X GET \
  "https://api.rememberizer.ai/api/v1/vector-stores/vs_abc123/documents/search?q=Wie%20integrieren%20wir%20unser%20Produkt%20mit%20Drittanbieter-Systemen&n=5&prev_chunks=1&next_chunks=1" \
  -H "x-api-key: YOUR_API_KEY"

Ersetzen Sie YOUR_API_KEY durch Ihren tatsächlichen Vector Store API-Schlüssel und vs_abc123 durch Ihre Vector Store-ID.

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',
  'Wie integrieren wir unser Produkt mit Drittanbieter-Systemen',
  5,
  1,
  1
);

Ersetzen Sie YOUR_API_KEY durch Ihren tatsächlichen Vector Store API-Schlüssel und vs_abc123 durch Ihre Vector Store-ID.

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',
    'Wie integrieren wir unser Produkt mit Drittanbieter-Systemen',
    5,
    1,
    1
)

Ersetzen Sie YOUR_API_KEY durch Ihren tatsächlichen Vector Store API-Schlüssel und vs_abc123 durch Ihre Vector Store-ID.

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',
  'Wie integrieren wir unser Produkt mit Drittanbieter-Systemen',
  5,
  1,
  1
)

Ersetzen Sie YOUR_API_KEY durch Ihren tatsächlichen Vector Store API-Schlüssel und vs_abc123 durch Ihre Vector Store-ID.

Pfadparameter

Parameter

Typ

Beschreibung

vector-store-id

string

Erforderlich. Die ID des Vektor-Speichers, in dem gesucht werden soll.

Abfrageparameter

Parameter

Typ

Beschreibung

Zeichenfolge

Erforderlich. Der Suchabfragetext.

Ganzzahl

Anzahl der zurückzugebenden Ergebnisse. Standard: 10.

Zahl

Übereinstimmungsschwelle. Standard: 0.7.

prev_chunks

Ganzzahl

Anzahl der Chunks vor dem übereinstimmenden Chunk, die einbezogen werden sollen. Standard: 0.

next_chunks

Ganzzahl

Anzahl der Chunks nach dem übereinstimmenden Chunk, die einbezogen werden sollen. Standard: 0.

Antwortformat

{
  "vector_store": {
    "id": "vs_abc123",
    "name": "Produktdokumentation"
  },
  "matched_chunks": [
    {
      "document": {
        "id": 1234,
        "name": "Integrationshandbuch.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": "Unser Produkt bietet mehrere Integrationsmöglichkeiten für Drittanbietersysteme. Die primäre Methode erfolgt über unsere RESTful API, die OAuth2-Authentifizierung unterstützt. Darüber hinaus können Sie unser SDK verwenden, das in Python, JavaScript und Java verfügbar ist.",
      "distance": 0.123
    },
    // ... weitere übereinstimmende Abschnitte
  ]
}

Authentifizierung

Dieser Endpunkt erfordert eine Authentifizierung mit einem API-Schlüssel im x-api-key-Header.

Fehlerantworten

Statuscode

Beschreibung

400

Ungültige Anfrage - Fehlende erforderliche Parameter oder ungültiges Format

401

Nicht autorisiert - Ungültiger oder fehlender API-Schlüssel

404

Nicht gefunden - Vektor-Speicher nicht gefunden

500

Interner Serverfehler

Tipps zur Suchoptimierung

Kontextfenster

Verwenden Sie die Parameter prev_chunks und next_chunks, um zu steuern, wie viel Kontext mit jedem Treffer einbezogen wird:

Setzen Sie beide auf 0 für präzise Übereinstimmungen ohne Kontext
Setzen Sie beide auf 1-2 für Übereinstimmungen mit minimalem Kontext
Setzen Sie beide auf 3-5 für Übereinstimmungen mit erheblichem Kontext

Übereinstimmungsgrenze

Der t-Parameter steuert, wie streng Übereinstimmungen gefiltert werden:

Höhere Werte (z. B. 0,9) geben nur sehr enge Übereinstimmungen zurück
Niedrigere Werte (z. B. 0,5) geben mehr Übereinstimmungen mit größerer Vielfalt zurück
Der Standardwert (0,7) bietet einen ausgewogenen Ansatz

Batch-Operationen

Für Anwendungen mit hohem Durchsatz unterstützt Rememberizer effiziente Batch-Operationen auf Vektorspeichern. Diese Methoden optimieren die Leistung bei der Verarbeitung mehrerer Suchanfragen.

Batch-Suchimplementierung

import requests
import time
import concurrent.futures

def batch_search_vector_store(vector_store_id, queries, num_results=5, batch_size=10):
    """
    Führen Sie Batch-Suchen gegen einen Vektorstore durch
    
    Args:
        vector_store_id: ID des Vektorstores, der durchsucht werden soll
        queries: Liste von Suchanfragen
        num_results: Anzahl der Ergebnisse pro Anfrage
        batch_size: Anzahl der parallelen Anfragen
        
    Returns:
        Liste der Suchergebnisse
    """
    headers = {
        "x-api-key": "YOUR_API_KEY"
    }
    
    results = []
    
    # In Batches verarbeiten, um die API nicht zu überlasten
    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
                }
                
                # Die Anfrage an den Thread-Pool übermitteln
                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)
            
            # Ergebnisse von allen Futures sammeln
            for future in futures:
                response = future.result()
                if response.status_code == 200:
                    results.append(response.json())
                else:
                    results.append({"error": f"Fehlgeschlagen mit Statuscode: {response.status_code}"})
        
        # Eine Verzögerung zwischen den Batches hinzufügen, um eine Ratenbegrenzung zu vermeiden
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

# Beispielverwendung
queries = [
    "Integration mit REST-APIs",
    "Authentifizierungsprotokolle",
    "Wie man in die Produktion deployt",
    "Techniken zur Leistungsoptimierung",
    "Best Practices für die Fehlerbehandlung"
]

search_results = batch_search_vector_store("vs_abc123", queries, num_results=3, batch_size=5)

/**
 * Führen Sie Batch-Suchen gegen einen Vektorstore durch
 * 
 * @param {string} vectorStoreId - ID des Vektorstores
 * @param {string[]} queries - Liste der Suchanfragen
 * @param {Object} options - Konfigurationsoptionen
 * @returns {Promise<Array>} - Liste der Suchergebnisse
 */
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';
  
  // In Batches verarbeiten, um die API-Belastung zu steuern
  for (let i = 0; i < queries.length; i += batchSize) {
    const batchQueries = queries.slice(i, i + batchSize);
    
    // Erstellen Sie ein Promise-Array für parallele Anfragen
    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: `Fehlgeschlagen mit Status: ${response.status}` };
        }
      })
      .catch(error => {
        return { error: error.message };
      });
    });
    
    // Warten Sie, bis alle Anfragen im Batch abgeschlossen sind
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Verzögerung zwischen den Batches hinzufügen, um Ratenbegrenzung zu vermeiden
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Beispielverwendung
const queries = [
  "Integration mit REST-APIs",
  "Authentifizierungsprotokolle",
  "Wie man in die Produktion deployt",
  "Techniken zur Leistungsoptimierung",
  "Best Practices für die Fehlerbehandlung"
];

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-Suche fehlgeschlagen:", error));

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

# Führen Sie Batch-Suchen gegen einen Vektor-Speicher durch
#
# @param vector_store_id [String] ID des Vektor-Speichers
# @param queries [Array<String>] Liste der Suchanfragen
# @param num_results [Integer] Anzahl der Ergebnisse pro Abfrage
# @param batch_size [Integer] Anzahl der parallelen Anfragen
# @param delay_between_batches [Float] Sekunden, die zwischen den Batches gewartet werden sollen
# @return [Array] Suchergebnisse für jede Abfrage
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'
  
  # In Batches verarbeiten
  queries.each_slice(batch_size).with_index do |batch_queries, batch_index|
    # Erstelle einen Thread-Pool für die gleichzeitige Ausführung
    pool = Concurrent::FixedThreadPool.new(batch_size)
    futures = []
    
    batch_queries.each do |query|
      # Jede Anfrage an den Thread-Pool übermitteln
      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" => "Fehlgeschlagen mit Statuscode: #{response.code}" }
          end
        rescue => e
          { "error" => e.message }
        end
      end
    end
    
    # Ergebnisse von allen Futures sammeln
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Verzögerung zwischen den Batches hinzufügen
    if batch_index < (queries.length / batch_size.to_f).ceil - 1
      sleep(delay_between_batches)
    end
  end
  
  pool.shutdown
  results
end

# Beispielnutzung
queries = [
  "Integration mit REST-APIs",
  "Authentifizierungsprotokolle",
  "Wie man in die Produktion deployt", 
  "Techniken zur Leistungsoptimierung",
  "Best Practices für die Fehlerbehandlung"
]

results = batch_search_vector_store(
  "vs_abc123", 
  queries, 
  num_results: 3, 
  batch_size: 5
)

puts results

Leistungsoptimierung für Batch-Operationen

Bei der Implementierung von Batch-Operationen für Suchen im Vektor-Store sollten Sie diese Best Practices berücksichtigen:

Optimale Batch-Größe: Für die meisten Anwendungen bietet die Verarbeitung von 5-10 Abfragen parallel ein gutes Gleichgewicht zwischen Durchsatz und Ressourcennutzung.
Bewusstsein für Ratenbegrenzung: Fügen Sie Verzögerungsmechanismen zwischen den Batches (typischerweise 1-2 Sekunden) hinzu, um zu vermeiden, dass die API-Ratenlimits überschritten werden.
Fehlerbehandlung: Implementieren Sie eine robuste Fehlerbehandlung für einzelne Abfragen, die innerhalb eines Batches fehlschlagen können.
Verbindungsmanagement: Für Anwendungen mit hohem Volumen implementieren Sie Connection Pooling, um den Overhead zu reduzieren.
Timeout-Konfiguration: Setzen Sie angemessene Timeouts für jede Anfrage, um zu verhindern, dass lang laufende Abfragen das gesamte Batch blockieren.
Ergebnisverarbeitung: Ziehen Sie in Betracht, Ergebnisse asynchron zu verarbeiten, sobald sie verfügbar sind, anstatt auf alle Ergebnisse zu warten.
Überwachung: Verfolgen Sie Leistungskennzahlen wie die durchschnittliche Antwortzeit und Erfolgsquoten, um Optimierungsmöglichkeiten zu identifizieren.

Für Produktionsanwendungen mit sehr hohen Abfragevolumina sollten Sie in Betracht ziehen, ein Warteschlangensystem mit Arbeitsprozessen zu implementieren, um große Batches effizient zu verwalten.

Dieser Endpunkt ermöglicht es Ihnen, Ihren Vektor-Store mithilfe von semantischer Ähnlichkeit zu durchsuchen. Er gibt Dokumente zurück, die konzeptionell mit Ihrer Abfrage verwandt sind, auch wenn sie nicht die genauen Schlüsselwörter enthalten. Dies macht ihn besonders leistungsfähig für natürliche Sprachabfragen und Fragenbeantwortung.

PreviousEin Dokument im Vektor-Speicher entfernen NextHinweise

Last updated 21 hours ago