# Søg efter dokumenter efter semantisk lighed

{% openapi src="<https://github.com/skydeckai/rememberizer-docs/blob/production/da/.gitbook/assets/rememberizer_openapi.yml>" path="/documents/search/" method="get" %}
<https://github.com/skydeckai/rememberizer-docs/blob/production/da/.gitbook/assets/rememberizer_openapi.yml>
{% endopenapi %}

## Eksempelanmodninger

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

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

{% hint style="info" %}
Erstat `YOUR_JWT_TOKEN` med din faktiske 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('Hvordan integrerer man Rememberizer med tilpassede applikationer', 5);
```

{% hint style="info" %}
Erstat `YOUR_JWT_TOKEN` med din faktiske 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("Hvordan integrerer man Rememberizer med tilpassede applikationer", 5)
```

{% hint style="info" %}
Erstat `YOUR_JWT_TOKEN` med din faktiske 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("Hvordan integrerer man Rememberizer med tilpassede applikationer", 5)
```

{% hint style="info" %}
Erstat `YOUR_JWT_TOKEN` med din faktiske JWT-token.
{% endhint %}
{% endtab %}
{% endtabs %}

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

```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": "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."

{% hint style="info" %}
For en dybere forståelse af, hvordan vektorindlejringer fungerer, og hvorfor denne søgemetode er effektiv, se [Hvad er Vektorindlejringer og Vektor Databaser?](/da/background/what-are-vector-embeddings-and-vector-databases.md)
{% endhint %}

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

{% 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):
    """
    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)
```

{% endtab %}

{% tab title="JavaScript" %}

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

{% endtab %}

{% tab title="Ruby" %}

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

{% endtab %}
{% endtabs %}

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


---

# 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/da/udviklerressourcer/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.