Søg efter dokumenter ved semantisk lighed

GET /documents/search/

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.

Parameter	In	Type	Required	Description
q	query	string		Up to 400 words sentence for which you wish to find semantically similar chunks of knowledge.
n	query	integer		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.
from	query	string		Start of the time range for documents to be searched, in ISO 8601 format.
to	query	string		End of the time range for documents to be searched, in ISO 8601 format.

Responses

• 200 — Successful retrieval of documents
• 400 — Bad request
• 401 — Unauthorized
• 404 — Not found
• 500 — Internal server error

Eksempelanmodninger

cURLJavaScriptPythonRuby

curl -X GET   
  "https://api.rememberizer.ai/api/v1/documents/search/?q=Hvordan%20integrerer%20man%20Rememberizer%20med%20tilpassede%20applikationer&n=5&from=2023-01-01T00:00:00Z&to=2023-12-31T23:59:59Z"   
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

Info

Erstat YOUR_JWT_TOKEN med din faktiske JWT-token.

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('Hvordan integrerer man Rememberizer med tilpassede applikationer', 5);

Info

Erstat YOUR_JWT_TOKEN med din faktiske JWT-token.

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("Hvordan integrerer man Rememberizer med tilpassede applikationer", 5)

Info

Erstat YOUR_JWT_TOKEN med din faktiske JWT-token.

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("Hvordan integrerer man Rememberizer med tilpassede applikationer", 5)

Info

Erstat YOUR_JWT_TOKEN med din faktiske JWT-token.

Forespørgselsparametre

Parameter	Type	Beskrivelse
q	string	Påkrævet. Den søgeforespørgselstekst (op til 400 ord).
n	integer	Antal resultater der skal returneres. Standard: 3. Brug højere værdier (f.eks. 10) for mere omfattende resultater.
from	string	Starten af tidsintervallet for dokumenter der skal søges, i ISO 8601 format.
to	string	Slutningen af tidsintervallet for dokumenter der skal søges, i ISO 8601 format.
prev_chunks	integer	Antal forudgående chunks der skal inkluderes for kontekst. Standard: 2.
next_chunks	integer	Antal følgende chunks der skal inkluderes for kontekst. Standard: 2.

Svarformat

{
  "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": "For at integrere Rememberizer med brugerdefinerede applikationer kan du bruge OAuth2-godkendelsesflowet til at autorisere din applikation til at få adgang til en brugers Rememberizer-data. Når du er autoriseret, kan din applikation bruge Rememberizer API'erne til at søge efter dokumenter, hente indhold og mere.",
      "distance": 0.123
    },
    // ... flere matchede dele
  ],
  "message": "Søgningen blev gennemført med succes",
  "code": "success"
}

Søgeoptimeringstips

Til Spørgsmål Svar

Når du søger efter et svar på et spørgsmål, så prøv at formulere din forespørgsel, som om det var et ideelt svar. For eksempel:

I stedet for: "Hvad er vektorindlejring?" Prøv: "Vektorindlejring er en teknik, der konverterer tekst til numeriske vektorer i et højdimensionelt rum."

Info

For en dybere forståelse af, hvordan vektorindlejringer fungerer, og hvorfor denne søgemetode er effektiv, se Hvad er Vektorindlejringer og Vektor Databaser?

Justering af Resultatantal

• Start med n=3 for hurtige, høj-relevante resultater
• Øg til n=10 eller højere for mere omfattende information
• Hvis søgningen returnerer utilstrækkelig information, prøv at øge n-parameteren

Tidsbaseret filtrering

Brug from og to parametrene til at fokusere på dokumenter fra specifikke tidsperioder:

• Nylige dokumenter: Sæt from til en nylig dato
• Historisk analyse: Angiv et specifikt datointerval
• Udelukke forældet information: Sæt en passende to dato

Batchoperationer

For effektivt at håndtere store mængder af søgeforespørgsler understøtter Rememberizer batchoperationer for at optimere ydeevnen og reducere API-opkaldsoverskuddet.

Batch Søgning

PythonJavaScriptRuby

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

def batch_search_documents(queries, num_results=5, batch_size=10):
    """
    Udfør batch søgninger med flere forespørgsler

    Args:
        queries: Liste af søgeforespørgselsstrenge
        num_results: Antal resultater der skal returneres pr. forespørgsel
        batch_size: Antal forespørgsler der skal behandles parallelt

    Returns:
        Liste af søgeresultater for hver forespørgsel
    """
    headers = {
        "Authorization": "Bearer YOUR_JWT_TOKEN",
        "Content-Type": "application/json"
    }

    results = []

    # Behandl forespørgsler i batches
    for i in range(0, len(queries), batch_size):
        batch = queries[i:i+batch_size]

        # Opret en trådpool for at sende forespørgsler parallelt
        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)

            # Indsaml resultater efterhånden som de fuldføres
            for future in futures:
                response = future.result()
                results.append(response.json())

        # Rate limiting - pause mellem batches for at undgå API throttling
        if i + batch_size < len(queries):
            time.sleep(1)

    return results

# Eksempel på brug
queries = [
    "Hvordan man bruger OAuth med Rememberizer",
    "Konfigurationsmuligheder for vektordatabaser",
    "Bedste praksis for semantisk søgning",
    # Tilføj flere forespørgsler efter behov
]

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

/**
 * Udfør batch-søgninger med flere forespørgsler
 * 
 * @param {string[]} queries - Liste over søgeforespørgsler
 * @param {number} numResults - Antal resultater der skal returneres pr. forespørgsel
 * @param {number} batchSize - Antal forespørgsler der skal behandles parallelt
 * @param {number} delayBetweenBatches - Millisekunder der skal ventes mellem batches
 * @returns {Promise<Array>} - Liste over søgeresultater for hver forespørgsel
 */
async function batchSearchDocuments(queries, numResults = 5, batchSize = 10, delayBetweenBatches = 1000) {
  const results = [];

  // Behandl forespørgsler i batches
  for (let i = 0; i < queries.length; i += batchSize) {
    const batch = queries.slice(i, i + batchSize);

    // Opret et array af promises for samtidige anmodninger
    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());
    });

    // Vent på at alle anmodninger i batchen er færdige
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);

    // Rate limiting - pause mellem batches for at undgå API-throttling
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }

  return results;
}

// Eksempel på brug
const queries = [
  "Hvordan man bruger OAuth med Rememberizer",
  "Konfigurationsmuligheder for vektordatabaser",
  "Bedste praksis for semantisk søgning",
  // Tilføj flere forespørgsler efter behov
];

batchSearchDocuments(queries, 3, 5)
  .then(results => console.log(results))
  .catch(error => console.error('Fejl i batch-søgning:', error));

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

# Udfør batch-søgninger med flere forespørgsler
#
# @param queries [Array<String>] Liste over søgeforespørgselsstrenge
# @param num_results [Integer] Antal resultater, der skal returneres pr. forespørgsel
# @param batch_size [Integer] Antal forespørgsler, der skal behandles parallelt
# @param delay_between_batches [Float] Sekunder at vente mellem batcher
# @return [Array] Liste over søgeresultater for hver forespørgsel
def batch_search_documents(queries, num_results = 5, batch_size = 10, delay_between_batches = 1.0)
  results = []

  # Behandl forespørgsler i batch
  queries.each_slice(batch_size).with_index do |batch, batch_index|
    # Opret en trådpool til samtidige anmodninger
    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

    # Indsaml resultater fra alle tråde
    batch_results = futures.map(&:value)
    results.concat(batch_results)

    # Hastighedsbegrænsning - pause mellem batches for at undgå API-throttling
    if batch_index < (queries.length / batch_size.to_f).ceil - 1
      sleep(delay_between_batches)
    end
  end

  pool.shutdown
  results
end

# Eksempel på brug
forespørgsler = [
  "Hvordan man bruger OAuth med Rememberizer",
  "Konfigurationsmuligheder for vektordatabaser",
  "Bedste praksis for semantisk søgning",
  # Tilføj flere forespørgsler efter behov
]

resultater = batch_search_documents(forespørgsler, 3, 5)
puts resultater

Ydelsesovervejelser

Når du implementerer batchoperationer, skal du overveje disse bedste praksisser:

1. Optimal Batchstørrelse: Start med batchstørrelser på 5-10 forespørgsler og juster baseret på din applikations ydelseskarakteristika.

2. Hastighedsbegrænsning: Inkluder forsinkelser mellem batcher for at forhindre API-throttling. Et godt udgangspunkt er 1 sekund mellem batcher.

3. Fejlhåndtering: Implementer robust fejlhåndtering for at håndtere mislykkede anmodninger inden for batcher.

4. Ressourcestyring: Overvåg klient-side ressourceforbrug, især med store batchstørrelser, for at forhindre overdreven hukommelsesforbrug.

5. Responsbehandling: Behandl batchresultater asynkront, når det er muligt, for at forbedre brugeroplevelsen.

For applikationer med høj volumen, overvej at implementere et køsystem for effektivt at håndtere et stort antal søgeanmodninger.

Denne endpoint giver kraftfulde semantiske søgefunktioner på tværs af din samlede vidensbase. Den bruger vektorindlejringer til at finde indhold baseret på betydning snarere end præcise nøgleordsmatch.