> For the complete documentation index, see [llms.txt](https://docs.rememberizer.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rememberizer.ai/de/entwicklerressourcen/api-docs/vector-store/search-for-vector-store-documents-by-semantic-similarity.md).

# Nach Dokumenten im Vektor-Speicher nach semantischer Ähnlichkeit suchen

{% openapi src="/files/ruiFvGmmJmrVu2Iycaim" path="/vector-stores/{vector-store-id}/documents/search" method="get" %}
[rememberizer\_openapi.yml](https://2490272757-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fx5M0COIHmFFlpJ9e5pvp%2Fuploads%2Fgit-blob-77b6137eeb641262ec8e531c78123c02b825b865%2Frememberizer_openapi.yml?alt=media\&token=22d7ca07-e3b4-475f-840e-857109bf09bc)
{% endopenapi %}

## Beispielanfragen

{% tabs %}
{% tab title="cURL" %}

```bash
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"
```

{% hint style="info" %}
Ersetzen Sie `YOUR_API_KEY` durch Ihren tatsächlichen Vector Store API-Schlüssel und `vs_abc123` durch Ihre Vector Store-ID.
{% endhint %}
{% endtab %}

{% tab title="JavaScript" %}

```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': '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
);
```

{% hint style="info" %}
Ersetzen Sie `YOUR_API_KEY` durch Ihren tatsächlichen Vector Store API-Schlüssel und `vs_abc123` durch Ihre Vector Store-ID.
{% endhint %}
{% endtab %}

{% tab title="Python" %}

```python
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
)
```

{% hint style="info" %}
Ersetzen Sie `YOUR_API_KEY` durch Ihren tatsächlichen Vector Store API-Schlüssel und `vs_abc123` durch Ihre Vector Store-ID.
{% endhint %}
{% endtab %}

{% tab title="Ruby" %}

```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'] = '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
)
```

{% hint style="info" %}
Ersetzen Sie `YOUR_API_KEY` durch Ihren tatsächlichen Vector Store API-Schlüssel und `vs_abc123` durch Ihre Vector Store-ID.
{% endhint %}
{% endtab %}
{% endtabs %}

## 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

```json
{
  "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

{% tabs %}
{% tab title="Python" %}

```python
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)
```

{% endtab %}

{% tab title="JavaScript" %}

```javascript
/**
 * 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));
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
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
```

{% endtab %}
{% endtabs %}

### Leistungsoptimierung für Batch-Operationen

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

1. **Optimale Batch-Größe**: Für die meisten Anwendungen bietet die Verarbeitung von 5-10 Abfragen parallel ein gutes Gleichgewicht zwischen Durchsatz und Ressourcennutzung.
2. **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.
3. **Fehlerbehandlung**: Implementieren Sie eine robuste Fehlerbehandlung für einzelne Abfragen, die innerhalb eines Batches fehlschlagen können.
4. **Verbindungsmanagement**: Für Anwendungen mit hohem Volumen implementieren Sie Connection Pooling, um den Overhead zu reduzieren.
5. **Timeout-Konfiguration**: Setzen Sie angemessene Timeouts für jede Anfrage, um zu verhindern, dass lang laufende Abfragen das gesamte Batch blockieren.
6. **Ergebnisverarbeitung**: Ziehen Sie in Betracht, Ergebnisse asynchron zu verarbeiten, sobald sie verfügbar sind, anstatt auf alle Ergebnisse zu warten.
7. **Ü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.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.rememberizer.ai/de/entwicklerressourcen/api-docs/vector-store/search-for-vector-store-documents-by-semantic-similarity.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.