Suche nach Vektor-Store-Dokumenten durch semantische Ähnlichkeit¶

`GET /vector-stores/{vector-store-id}/documents/search`¶

Initiate a search operation with a query text and receive most semantically similar responses from the vector store.

Parameter	In	Type	Required	Description
`vector-store-id`	path	string	yes	The ID of the vector store.
`q`	query	string	yes	The search query text.
`n`	query	integer		Number of chunks to return.
`t`	query	number		Matching threshold.
`prev_chunks`	query	integer		Number of chunks before the matched chunk to include.
`next_chunks`	query	integer		Number of chunks after the matched chunk to include.
`x-api-key`	header	string	yes	The API key for authentication.

Responses

200 — Search results retrieved successfully.

Beispielanfragen¶

cURLJavaScriptPythonRuby

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"

Info

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

Info

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
)

Info

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(/de/developer-resources/integration-options/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
)

Info

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¶

PythonJavaScriptRuby

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(/de/developer-resources/integration-options/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.

Suche nach Vektor-Store-Dokumenten durch semantische Ähnlichkeit¶

GET /vector-stores/{vector-store-id}/documents/search¶

Beispielanfragen¶

Pfadparameter¶

Abfrageparameter¶

Antwortformat¶

Authentifizierung¶

Fehlerantworten¶

Tipps zur Suchoptimierung¶

Kontextfenster¶

Übereinstimmungsgrenze¶

Batch-Operationen¶

Batch-Suchimplementierung¶

Leistungsoptimierung für Batch-Operationen¶

`GET /vector-stores/{vector-store-id}/documents/search`¶