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
q
Zeichenfolge
Erforderlich. Der Suchabfragetext.
n
Ganzzahl
Anzahl der zurückzugebenden Ergebnisse. Standard: 10.
t
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.
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
GET /api/v1/vector-stores/{vector-store-id}/documents/search HTTP/1.1
Host: api.rememberizer.ai
x-api-key: text
Accept: */*
