Dokumente nach semantischer Ähnlichkeit suchen

Semantischer Suchendpunkt mit Batch-Verarbeitungsfunktionen

get

Initiate a search operation with a query text of up to 400 words and receive the most semantically similar responses from the stored knowledge. For question-answering, convert your question into an ideal answer and submit it to receive similar real answers.

Query parameters

qstringOptional

Up to 400 words sentence for which you wish to find semantically similar chunks of knowledge.

nintegerOptional

Number of semantically similar chunks of text to return. Use 'n=3' for up to 5, and 'n=10' for more information. If you do not receive enough information, consider trying again with a larger 'n' value.

fromstring · date-timeOptional

Start of the time range for documents to be searched, in ISO 8601 format.

tostring · date-timeOptional

End of the time range for documents to be searched, in ISO 8601 format.

Responses

200

Successful retrieval of documents

application/json

400

Bad request

401

Unauthorized

404

Not found

500

Internal server error

get

HTTPcURLJavaScriptPython

GET /api/v1/documents/search/ HTTP/1.1
Host: api.rememberizer.ai
Accept: */*

{
  "data_sources": [
    {
      "name": "text",
      "documents": 1
    }
  ],
  "matched_chunks": [
    {
      "document": {
        "id": 18,
        "document_id": "text",
        "name": "text",
        "type": "text",
        "path": "text",
        "url": "text",
        "size": 1,
        "created_time": "2025-05-21T07:55:23.256Z",
        "modified_time": "2025-05-21T07:55:23.256Z",
        "indexed_on": "2025-05-21T07:55:23.256Z",
        "integration": {
          "id": 1,
          "integration_type": "text"
        }
      },
      "matched_content": "text",
      "distance": 1
    }
  ]
}

Beispielanfragen

cURL

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"

Ersetzen Sie YOUR_JWT_TOKEN durch Ihr tatsächliches JWT-Token.

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

Ersetzen Sie YOUR_JWT_TOKEN durch Ihr tatsächliches JWT-Token.

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)

Ersetzen Sie YOUR_JWT_TOKEN durch Ihr tatsächliches JWT-Token.

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)

Ersetzen Sie YOUR_JWT_TOKEN durch Ihr tatsächliches JWT-Token.

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

{
  "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."

Für ein tieferes Verständnis, wie Vektor-Embeddings funktionieren und warum dieser Suchansatz effektiv ist, siehe Was sind Vektor-Embeddings und Vektor-Datenbanken?

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

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)

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

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

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.