# Nach Dokumenten nach semantischer Ähnlichkeit suchen

{% openapi src="/files/ruiFvGmmJmrVu2Iycaim" path="/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/documents/search/?q=Wie%20man%20Rememberizer%20mit%20benutzerdefinierten%20Anwendungen%20integriert&n=5&from=2023-01-01T00:00:00Z&to=2023-12-31T23:59:59Z" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"
```

{% hint style="info" %}
Ersetzen Sie `YOUR_JWT_TOKEN` durch Ihr tatsächliches JWT-Token.
{% endhint %}
{% endtab %}

{% tab title="JavaScript" %}

```javascript
const searchDocuments = async (query, numResults = 5, from = null, to = null) => {
  const url = new URL('https://api.rememberizer.ai/api/v1/documents/search/');
  url.searchParams.append('q', query);
  url.searchParams.append('n', numResults);
  
  if (from) {
    url.searchParams.append('from', from);
  }
  
  if (to) {
    url.searchParams.append('to', to);
  }
  
  const response = await fetch(url.toString(), {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_JWT_TOKEN'
    }
  });
  
  const data = await response.json();
  console.log(data);
};

searchDocuments('Wie man Rememberizer mit benutzerdefinierten Anwendungen integriert', 5);
```

{% hint style="info" %}
Ersetzen Sie `YOUR_JWT_TOKEN` durch Ihr tatsächliches JWT-Token.
{% endhint %}
{% endtab %}

{% tab title="Python" %}

```python
import requests

def search_documents(query, num_results=5, from_date=None, to_date=None):
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN"
    }
    
    params = {
        "q": query,
        "n": num_results
    }
    
    if from_date:
        params["from"] = from_date
    
    if to_date:
        params["to"] = to_date
    
    response = requests.get(
        "https://api.rememberizer.ai/api/v1/documents/search/",
        headers=headers,
        params=params
    )
    
    data = response.json()
    print(data)

search_documents("Wie man Rememberizer mit benutzerdefinierten Anwendungen integriert", 5)
```

{% hint style="info" %}
Ersetzen Sie `YOUR_JWT_TOKEN` durch Ihr tatsächliches JWT-Token.
{% endhint %}
{% endtab %}

{% tab title="Ruby" %}

```ruby
require 'net/http'
require 'uri'
require 'json'

def search_documents(query, num_results=5, from_date=nil, to_date=nil)
  uri = URI('https://api.rememberizer.ai/api/v1/documents/search/')
  params = {
    q: query,
    n: num_results
  }
  
  params[:from] = from_date if from_date
  params[:to] = to_date if to_date
  
  uri.query = URI.encode_www_form(params)
  
  request = Net::HTTP::Get.new(uri)
  request['Authorization'] = 'Bearer YOUR_JWT_TOKEN'
  
  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_documents("Wie man Rememberizer mit benutzerdefinierten Anwendungen integriert", 5)
```

{% hint style="info" %}
Ersetzen Sie `YOUR_JWT_TOKEN` durch Ihr tatsächliches JWT-Token.
{% endhint %}
{% endtab %}
{% endtabs %}

## Abfrageparameter

| Parameter    | Typ     | Beschreibung                                                                                                            |
| ------------ | ------- | ----------------------------------------------------------------------------------------------------------------------- |
| q            | string  | **Erforderlich.** Der Suchanfragetext (bis zu 400 Wörter).                                                              |
| n            | integer | Anzahl der zurückzugebenden Ergebnisse. Standard: 3. Verwenden Sie höhere Werte (z. B. 10) für umfassendere Ergebnisse. |
| from         | string  | Beginn des Zeitraums für die zu durchsuchenden Dokumente im ISO 8601-Format.                                            |
| to           | string  | Ende des Zeitraums für die zu durchsuchenden Dokumente im ISO 8601-Format.                                              |
| prev\_chunks | integer | Anzahl der vorhergehenden Abschnitte, die für den Kontext einbezogen werden sollen. Standard: 2.                        |
| next\_chunks | integer | Anzahl der folgenden Abschnitte, die für den Kontext einbezogen werden sollen. Standard: 2.                             |

## Antwortformat

```json
{
  "data_sources": [
    {
      "name": "Google Drive",
      "documents": 3
    },
    {
      "name": "Slack",
      "documents": 2
    }
  ],
  "matched_chunks": [
    {
      "document": {
        "id": 12345,
        "document_id": "1aBcD2efGhIjK3lMnOpQrStUvWxYz",
        "name": "Rememberizer API Dokumentation.pdf",
        "type": "application/pdf",
        "path": "/Documents/Rememberizer/API Dokumentation.pdf",
        "url": "https://drive.google.com/file/d/1aBcD2efGhIjK3lMnOpQrStUvWxYz/view",
        "size": 250000,
        "created_time": "2023-05-10T14:30:00Z",
        "modified_time": "2023-06-15T09:45:00Z",
        "indexed_on": "2023-06-15T10:30:00Z",
        "integration": {
          "id": 101,
          "integration_type": "google_drive"
        }
      },
      "matched_content": "Um Rememberizer mit benutzerdefinierten Anwendungen zu integrieren, können Sie den OAuth2-Authentifizierungsfluss verwenden, um Ihre Anwendung zu autorisieren, auf die Daten eines Benutzers von Rememberizer zuzugreifen. Nach der Autorisierung kann Ihre Anwendung die Rememberizer-APIs verwenden, um nach Dokumenten zu suchen, Inhalte abzurufen und mehr.",
      "distance": 0.123
    },
    // ... weitere übereinstimmende Abschnitte
  ],
  "message": "Suche erfolgreich abgeschlossen",
  "code": "success"
}
```

## Tipps zur Suchoptimierung

### Für die Beantwortung von Fragen

Wenn Sie nach einer Antwort auf eine Frage suchen, versuchen Sie, Ihre Anfrage so zu formulieren, als wäre sie die ideale Antwort. Zum Beispiel:

Statt: "Was ist Vektor-Embedding?" Versuchen Sie: "Vektor-Embedding ist eine Technik, die Text in numerische Vektoren in einem hochdimensionalen Raum umwandelt."

{% hint style="info" %}
Für ein tieferes Verständnis, wie Vektor-Embeddings funktionieren und warum dieser Suchansatz effektiv ist, siehe [Was sind Vektor-Embeddings und Vektor-Datenbanken?](/de/background/what-are-vector-embeddings-and-vector-databases.md)
{% endhint %}

### Anpassung der Ergebnisanzahl

* Beginnen Sie mit `n=3` für schnelle, hochrelevante Ergebnisse
* Erhöhen Sie auf `n=10` oder höher für umfassendere Informationen
* Wenn die Suche unzureichende Informationen zurückgibt, versuchen Sie, den `n`-Parameter zu erhöhen

### Zeitbasierte Filterung

Verwenden Sie die Parameter `from` und `to`, um sich auf Dokumente aus bestimmten Zeiträumen zu konzentrieren:

* Aktuelle Dokumente: Setzen Sie `from` auf ein aktuelles Datum
* Historische Analyse: Geben Sie einen bestimmten Datumsbereich an
* Ausschluss veralteter Informationen: Setzen Sie ein angemessenes `to` Datum

## Batch-Operationen

Um große Mengen von Suchanfragen effizient zu bearbeiten, unterstützt Rememberizer Batch-Operationen, um die Leistung zu optimieren und die API-Aufrufkosten zu reduzieren.

### Batch-Suche

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

```python
import requests
import time
import json
from concurrent.futures import ThreadPoolExecutor

def batch_search_documents(queries, num_results=5, batch_size=10):
    """
    Führen Sie Batch-Suchen mit mehreren Abfragen durch
    
    Args:
        queries: Liste von Suchabfrage-Strings
        num_results: Anzahl der Ergebnisse, die pro Abfrage zurückgegeben werden sollen
        batch_size: Anzahl der Abfragen, die parallel verarbeitet werden sollen
    
    Returns:
        Liste der Suchergebnisse für jede Abfrage
    """
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN",
        "Content-Type": "application/json"
    }
    
    results = []
    
    # Verarbeiten Sie Abfragen in Batches
    for i in range(0, len(queries), batch_size):
        batch = queries[i:i+batch_size]
        
        # Erstellen Sie einen Thread-Pool, um Anfragen parallel zu senden
        with ThreadPoolExecutor(max_workers=batch_size) as executor:
            futures = []
            
            for query in batch:
                params = {
                    "q": query,
                    "n": num_results
                }
                
                future = executor.submit(
                    requests.get,
                    "https://api.rememberizer.ai/api/v1/documents/search/",
                    headers=headers,
                    params=params
                )
                futures.append(future)
            
            # Ergebnisse sammeln, während sie abgeschlossen werden
            for future in futures:
                response = future.result()
                results.append(response.json())
        
        # Ratenbegrenzung - Pause zwischen Batches, um API-Drosselung zu vermeiden
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

# Beispielverwendung
queries = [
    "Wie man OAuth mit Rememberizer verwendet",
    "Konfigurationsoptionen für Vektordatenbanken",
    "Best Practices für die semantische Suche",
    # Fügen Sie bei Bedarf weitere Abfragen hinzu
]

results = batch_search_documents(queries, num_results=3, batch_size=5)
```

{% endtab %}

{% tab title="JavaScript" %}

```javascript
/**
 * Führen Sie Batch-Suchen mit mehreren Abfragen durch
 * 
 * @param {string[]} queries - Liste der Suchabfrage-Strings
 * @param {number} numResults - Anzahl der Ergebnisse, die pro Abfrage zurückgegeben werden sollen
 * @param {number} batchSize - Anzahl der Abfragen, die parallel verarbeitet werden sollen
 * @param {number} delayBetweenBatches - Millisekunden, die zwischen den Batches gewartet werden sollen
 * @returns {Promise<Array>} - Liste der Suchergebnisse für jede Abfrage
 */
async function batchSearchDocuments(queries, numResults = 5, batchSize = 10, delayBetweenBatches = 1000) {
  const results = [];
  
  // Verarbeiten Sie Abfragen in Batches
  for (let i = 0; i < queries.length; i += batchSize) {
    const batch = queries.slice(i, i + batchSize);
    
    // Erstellen Sie ein Array von Promises für gleichzeitige Anfragen
    const batchPromises = batch.map(query => {
      const url = new URL('https://api.rememberizer.ai/api/v1/documents/search/');
      url.searchParams.append('q', query);
      url.searchParams.append('n', numResults);
      
      return fetch(url.toString(), {
        method: 'GET',
        headers: {
          'Authorization': 'Bearer YOUR_JWT_TOKEN'
        }
      }).then(response => response.json());
    });
    
    // Warten Sie, bis alle Anfragen im Batch abgeschlossen sind
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Ratenbegrenzung - Pause zwischen den Batches, um API-Drosselung zu vermeiden
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Beispielverwendung
const queries = [
  "Wie man OAuth mit Rememberizer verwendet",
  "Konfigurationsoptionen für Vektordatenbanken",
  "Best Practices für die semantische Suche",
  // Fügen Sie bei Bedarf weitere Abfragen hinzu
];

batchSearchDocuments(queries, 3, 5)
  .then(results => console.log(results))
  .catch(error => console.error('Fehler bei der Batch-Suche:', error));
```

{% endtab %}

{% tab title="Ruby" %}

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

# Führen Sie Batch-Suchen mit mehreren Abfragen durch
#
# @param queries [Array<String>] Liste der Suchabfrage-Strings
# @param num_results [Integer] Anzahl der Ergebnisse, die pro Abfrage zurückgegeben werden sollen
# @param batch_size [Integer] Anzahl der Abfragen, die parallel verarbeitet werden sollen
# @param delay_between_batches [Float] Sekunden, die zwischen den Batches gewartet werden sollen
# @return [Array] Liste der Suchergebnisse für jede Abfrage
def batch_search_documents(queries, num_results = 5, batch_size = 10, delay_between_batches = 1.0)
  results = []
  
  # Abfragen in Chargen verarbeiten
  queries.each_slice(batch_size).with_index do |batch, batch_index|
    # Erstellen eines Thread-Pools für gleichzeitige Anfragen
    pool = Concurrent::FixedThreadPool.new(batch_size)
    futures = []
    
    batch.each do |query|
      futures << Concurrent::Future.execute(executor: pool) do
        uri = URI('https://api.rememberizer.ai/api/v1/documents/search/')
        params = {
          q: query,
          n: num_results
        }
        
        uri.query = URI.encode_www_form(params)
        
        request = Net::HTTP::Get.new(uri)
        request['Authorization'] = 'Bearer YOUR_JWT_TOKEN'
        
        http = Net::HTTP.new(uri.host, uri.port)
        http.use_ssl = true
        
        response = http.request(request)
        JSON.parse(response.body)
      end
    end
    
    # Ergebnisse von allen Threads sammeln
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Ratenbegrenzung - Pause zwischen Chargen, um API-Drosselung zu vermeiden
    if batch_index < (queries.length / batch_size.to_f).ceil - 1
      sleep(delay_between_batches)
    end
  end
  
  pool.shutdown
  results
end

# Beispielverwendung
queries = [
  "Wie man OAuth mit Rememberizer verwendet",
  "Konfigurationsoptionen für Vektordatenbanken",
  "Best Practices für semantische Suche",
  # Weitere Abfragen nach Bedarf hinzufügen
]

results = batch_search_documents(queries, 3, 5)
puts results
```

{% endtab %}
{% endtabs %}

### Leistungsüberlegungen

Bei der Implementierung von Batch-Operationen sollten Sie diese Best Practices berücksichtigen:

1. **Optimale Batch-Größe**: Beginnen Sie mit Batch-Größen von 5-10 Abfragen und passen Sie diese basierend auf den Leistungsmerkmalen Ihrer Anwendung an.
2. **Ratenbegrenzung**: Fügen Sie zwischen den Batches Verzögerungen ein, um API-Drosselung zu verhindern. Ein guter Ausgangspunkt sind 1 Sekunde zwischen den Batches.
3. **Fehlerbehandlung**: Implementieren Sie eine robuste Fehlerbehandlung, um fehlgeschlagene Anfragen innerhalb der Batches zu verwalten.
4. **Ressourcenmanagement**: Überwachen Sie die clientseitige Ressourcennutzung, insbesondere bei großen Batch-Größen, um übermäßigen Speicherverbrauch zu vermeiden.
5. **Antwortverarbeitung**: Verarbeiten Sie Batch-Ergebnisse asynchron, wenn möglich, um die Benutzererfahrung zu verbessern.

Für Anwendungen mit hohem Volumen sollten Sie in Betracht ziehen, ein Warteschlangensystem zu implementieren, um eine große Anzahl von Suchanfragen effizient zu verwalten.

Dieser Endpunkt bietet leistungsstarke semantische Suchfunktionen für Ihre gesamte Wissensdatenbank. Er verwendet Vektor-Embeddings, um Inhalte basierend auf der Bedeutung und nicht auf genauen Schlüsselwortübereinstimmungen zu finden.


---

# Agent Instructions: 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/search-for-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.