Rememberizer Docs
RegistrazioneIscrizioneContattaci
Italiano
Italiano
  • Perché Rememberizer?
  • Contesto
    • Cosa sono gli Embedding Vettoriali e i Database Vettoriali?
    • Glossario
    • Terminologia Standardizzata
  • Uso personale
    • Iniziare
      • Cerca la tua conoscenza
      • Accesso al filtro Mementos
      • Conoscenza comune
      • Gestisci la tua conoscenza incorporata
  • Integrazioni
    • App Rememberizer
    • Integrazione Rememberizer Slack
    • Integrazione Rememberizer Google Drive
    • Integrazione Rememberizer Dropbox
    • Integrazione Rememberizer Gmail
    • Integrazione Rememberizer Memory
    • Server MCP Rememberizer
    • Gestisci app di terze parti
  • Risorse per Sviluppatori
    • Panoramica per Sviluppatori
  • Opzioni di integrazione
    • Registrazione e utilizzo delle chiavi API
    • Registrazione delle app Rememberizer
    • Autorizzazione delle app Rememberizer
    • Creazione di un Rememberizer GPT
    • Integrazione con LangChain
    • Archivi vettoriali
    • Talk-to-Slack l'app web di esempio
  • Integrazione Aziendale
    • Modelli di Integrazione Aziendale
  • Riferimento API
    • Home Documentazione API
    • Autenticazione
  • API principali
    • Cerca documenti per somiglianza semantica
    • Recupera documenti
    • Recupera contenuti dei documenti
    • Recupera contenuti di Slack
    • Memorizza contenuti in Rememberizer
  • Account & Configurazione
    • Recupera i dettagli dell'account utente corrente
    • Elenca le integrazioni delle fonti di dati disponibili
    • Mementi
    • Ottieni tutta la conoscenza pubblica aggiunta
  • API di Archiviazione Vettoriale
    • Documentazione dell'Archiviazione Vettoriale
    • Ottieni informazioni sull'archiviazione vettoriale
    • Ottieni un elenco di documenti in un'Archiviazione Vettoriale
    • Ottieni informazioni sul documento
    • Aggiungi un nuovo documento di testo a un'Archiviazione Vettoriale
    • Carica file in un'Archiviazione Vettoriale
    • Aggiorna il contenuto del file in un'Archiviazione Vettoriale
    • Rimuovi un documento nell'Archiviazione Vettoriale
    • Cerca documenti dell'Archiviazione Vettoriale per somiglianza semantica
  • Risorse Aggiuntive
    • Avvisi
      • Termini di Utilizzo
      • Informativa sulla Privacy
      • B2B
        • Informazioni su Reddit Agent
  • Rilasci
    • Note di Rilascio Home
  • Rilasci 2025
    • 25 Aprile 2025
    • 18 Aprile 2025
    • 11 Aprile 2025
    • 4 Aprile 2025
    • 28 Marzo 2025
    • 21 Marzo 2025
    • 14 Marzo 2025
    • 17 Gennaio 2025
  • Rilasci 2024
    • 27 Dicembre 2024
    • 20 Dicembre 2024
    • 13 Dicembre 2024
    • 6 Dicembre 2024
  • 29 Nov 2024
  • 22 Nov 2024
  • 15 Nov 2024
  • 8 Nov 2024
  • 1 Nov 2024
  • 25 Ottobre 2024
  • 18 Ottobre 2024
  • 11 Ottobre 2024
  • 4 Ottobre 2024
  • 27 Settembre 2024
  • 20 Settembre 2024
  • 13 Settembre 2024
  • 16 Ago 2024
  • 9 Ago 2024
  • 2 Ago 2024
  • 26 Lug 2024
  • 12 Lug 2024
  • 28 Giugno 2024
  • 14 Giugno 2024
  • 31 maggio 2024
  • 17 maggio 2024
  • 10 maggio 2024
  • 26 Aprile 2024
  • 19 Aprile 2024
  • 12 Aprile 2024
  • 5 Aprile 2024
  • 25 Mar 2024
  • 18 Mar 2024
  • 11 Mar 2024
  • 4 Mar 2024
  • 26 Febbraio 2024
  • 19 Febbraio 2024
  • 12 Febbraio 2024
  • 5 Febbraio 2024
  • 29 Gennaio 2024
  • 22 Gennaio 2024
  • 15 Gennaio 2024
  • Documentazione LLM
    • Documentazione LLM Pronta di Rememberizer
Powered by GitBook
On this page
  1. API di Archiviazione Vettoriale

Cerca documenti dell'Archiviazione Vettoriale per somiglianza semantica

Cerca documenti del Vector Store con somiglianza semantica e operazioni in batch

PreviousRimuovi un documento nell'Archiviazione VettorialeNextAvvisi

Last updated 24 days ago

Esempi di Richieste

curl -X GET \
  "https://api.rememberizer.ai/api/v1/vector-stores/vs_abc123/documents/search?q=Come%20integrare%20il%20nostro%20prodotto%20con%20sistemi%20di%20terze%20parti&n=5&prev_chunks=1&next_chunks=1" \
  -H "x-api-key: YOUR_API_KEY"

Sostituisci YOUR_API_KEY con la tua reale chiave API del Vector Store e vs_abc123 con il tuo ID del Vector Store.

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',
  'Come integrare il nostro prodotto con sistemi di terze parti',
  5,
  1,
  1
);

Sostituisci YOUR_API_KEY con la tua reale chiave API del Vector Store e vs_abc123 con il tuo ID del Vector Store.

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',
    'Come integrare il nostro prodotto con sistemi di terze parti',
    5,
    1,
    1
)

Sostituisci YOUR_API_KEY con la tua reale chiave API del Vector Store e vs_abc123 con il tuo ID del Vector Store.

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',
  'Come integrare il nostro prodotto con sistemi di terze parti',
  5,
  1,
  1
)

Sostituisci YOUR_API_KEY con la tua reale chiave API del Vector Store e vs_abc123 con il tuo ID del Vector Store.

Parametri del percorso

Parametro
Tipo
Descrizione

vector-store-id

string

Obbligatorio. L'ID del negozio di vettori in cui cercare.

Parametri di Query

Parametro
Tipo
Descrizione

q

string

Obbligatorio. Il testo della query di ricerca.

n

integer

Numero di risultati da restituire. Predefinito: 10.

t

number

Soglia di corrispondenza. Predefinito: 0.7.

prev_chunks

integer

Numero di chunk prima del chunk corrispondente da includere. Predefinito: 0.

next_chunks

integer

Numero di chunk dopo il chunk corrispondente da includere. Predefinito: 0.

Formato di Risposta

{
  "vector_store": {
    "id": "vs_abc123",
    "name": "Documentazione del Prodotto"
  },
  "matched_chunks": [
    {
      "document": {
        "id": 1234,
        "name": "Guida all'Integrazione.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": "Il nostro prodotto offre diverse opzioni di integrazione per sistemi di terze parti. Il metodo principale è attraverso la nostra API RESTful, che supporta l'autenticazione OAuth2. Inoltre, puoi utilizzare il nostro SDK disponibile in Python, JavaScript e Java.",
      "distance": 0.123
    },
    // ... più chunk corrispondenti
  ]
}

Autenticazione

Questo endpoint richiede autenticazione utilizzando una chiave API nell'intestazione x-api-key.

Risposte di Errore

Codice di Stato
Descrizione

400

Richiesta Errata - Parametri richiesti mancanti o formato non valido

401

Non Autorizzato - Chiave API non valida o mancante

404

Non Trovato - Negozio di Vettori non trovato

500

Errore Interno del Server

Suggerimenti per l'Ottimizzazione della Ricerca

Finestre di Contesto

Utilizza i parametri prev_chunks e next_chunks per controllare quanto contesto è incluso con ogni corrispondenza:

  • Imposta entrambi a 0 per corrispondenze precise senza contesto

  • Imposta entrambi a 1-2 per corrispondenze con contesto minimo

  • Imposta entrambi a 3-5 per corrispondenze con contesto sostanziale

Soglia di Corrispondenza

Il parametro t controlla quanto rigorosamente vengono filtrate le corrispondenze:

  • Valori più alti (ad es., 0.9) restituiscono solo corrispondenze molto vicine

  • Valori più bassi (ad es., 0.5) restituiscono più corrispondenze con maggiore varietà

  • Il valore predefinito (0.7) fornisce un approccio equilibrato

Operazioni in Batch

Per applicazioni ad alta capacità, Rememberizer supporta operazioni in batch efficienti sui vettori di archiviazione. Questi metodi ottimizzano le prestazioni durante l'elaborazione di più query di ricerca.

Implementazione della Ricerca in Batch

import requests
import time
import concurrent.futures

def batch_search_vector_store(vector_store_id, queries, num_results=5, batch_size=10):
    """
    Esegui ricerche in batch su un archivio vettoriale
    
    Args:
        vector_store_id: ID dell'archivio vettoriale da cercare
        queries: Elenco delle stringhe di query di ricerca
        num_results: Numero di risultati per query
        batch_size: Numero di richieste parallele
        
    Returns:
        Elenco dei risultati della ricerca
    """
    headers = {
        "x-api-key": "YOUR_API_KEY"
    }
    
    results = []
    
    # Elabora in batch per evitare di sovraccaricare l'API
    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
                }
                
                # Invia la richiesta al pool di thread
                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)
            
            # Raccogli i risultati da tutti i futures
            for future in futures:
                response = future.result()
                if response.status_code == 200:
                    results.append(response.json())
                else:
                    results.append({"error": f"Fallito con codice di stato: {response.status_code}"})
        
        # Aggiungi un ritardo tra i batch per evitare limitazioni di frequenza
        if i + batch_size < len(queries):
            time.sleep(1)
    
    return results

# Esempio di utilizzo
queries = [
    "Integrazione con le API REST",
    "Protocolli di autenticazione",
    "Come distribuire in produzione",
    "Tecniche di ottimizzazione delle prestazioni",
    "Migliori pratiche per la gestione degli errori"
]

search_results = batch_search_vector_store("vs_abc123", queries, num_results=3, batch_size=5)
/**
 * Esegui ricerche in batch contro un archivio vettoriale
 * 
 * @param {string} vectorStoreId - ID dell'archivio vettoriale
 * @param {string[]} queries - Elenco delle query di ricerca
 * @param {Object} options - Opzioni di configurazione
 * @returns {Promise<Array>} - Elenco dei risultati della ricerca
 */
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';
  
  // Elabora in batch per gestire il carico dell'API
  for (let i = 0; i < queries.length; i += batchSize) {
    const batchQueries = queries.slice(i, i + batchSize);
    
    // Crea un array di promesse per richieste parallele
    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: `Fallito con stato: ${response.status}` };
        }
      })
      .catch(error => {
        return { error: error.message };
      });
    });
    
    // Aspetta che tutte le richieste nel batch siano completate
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Aggiungi un ritardo tra i batch per evitare il limite di frequenza
    if (i + batchSize < queries.length) {
      await new Promise(resolve => setTimeout(resolve, delayBetweenBatches));
    }
  }
  
  return results;
}

// Esempio di utilizzo
const queries = [
  "Integrazione con le API REST",
  "Protocolli di autenticazione",
  "Come distribuire in produzione",
  "Tecniche di ottimizzazione delle prestazioni",
  "Migliori pratiche per la gestione degli errori"
];

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("La ricerca in batch è fallita:", error));
require 'net/http'
require 'uri'
require 'json'
require 'concurrent'

# Esegui ricerche in batch contro un archivio vettoriale
#
# @param vector_store_id [String] ID del negozio di vettori
# @param queries [Array<String>] Elenco delle query di ricerca
# @param num_results [Integer] Numero di risultati per query
# @param batch_size [Integer] Numero di richieste parallele
# @param delay_between_batches [Float] Secondi da attendere tra i batch
# @return [Array] Risultati della ricerca per ogni query
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'
  
  # Elaborare in batch
  queries.each_slice(batch_size).with_index do |batch_queries, batch_index|
    # Creare un pool di thread per l'esecuzione concorrente
    pool = Concurrent::FixedThreadPool.new(batch_size)
    futures = []
    
    batch_queries.each do |query|
      # Inviare ogni richiesta al pool di thread
      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" => "Fallito con codice di stato: #{response.code}" }
          end
        rescue => e
          { "error" => e.message }
        end
      end
    end
    
    # Raccogliere i risultati da tutti i futures
    batch_results = futures.map(&:value)
    results.concat(batch_results)
    
    # Aggiungere un ritardo tra i batch
    if batch_index < (queries.length / batch_size.to_f).ceil - 1
      sleep(delay_between_batches)
    end
  end
  
  pool.shutdown
  results
end

# Esempio di utilizzo
queries = [
  "Integrazione con le API REST",
  "Protocolli di autenticazione",
  "Come distribuire in produzione", 
  "Tecniche di ottimizzazione delle prestazioni",
  "Migliori pratiche per la gestione degli errori"
]

results = batch_search_vector_store(
  "vs_abc123", 
  queries, 
  num_results: 3, 
  batch_size: 5
)

puts results

Ottimizzazione delle Prestazioni per Operazioni in Batch

Quando si implementano operazioni in batch per le ricerche nel vector store, considera queste migliori pratiche:

  1. Dimensionamento Ottimale del Batch: Per la maggior parte delle applicazioni, elaborare 5-10 query in parallelo offre un buon equilibrio tra throughput e utilizzo delle risorse.

  2. Consapevolezza del Rate Limiting: Includi meccanismi di ritardo tra i batch (tipicamente 1-2 secondi) per evitare di superare i limiti di velocità dell'API.

  3. Gestione degli Errori: Implementa una gestione robusta degli errori per le singole query che potrebbero fallire all'interno di un batch.

  4. Gestione delle Connessioni: Per applicazioni ad alto volume, implementa il pooling delle connessioni per ridurre il sovraccarico.

  5. Configurazione dei Timeout: Imposta timeout appropriati per ogni richiesta per evitare che query a lungo termine blocchino l'intero batch.

  6. Elaborazione dei Risultati: Considera di elaborare i risultati in modo asincrono man mano che diventano disponibili piuttosto che attendere tutti i risultati.

  7. Monitoraggio: Monitora metriche di prestazione come il tempo medio di risposta e i tassi di successo per identificare opportunità di ottimizzazione.

Per applicazioni di produzione con volumi di query molto elevati, considera di implementare un sistema di coda con processi di lavoro per gestire grandi batch in modo efficiente.

Questo endpoint ti consente di cercare nel tuo vector store utilizzando la similarità semantica. Restituisce documenti che sono concettualmente correlati alla tua query, anche se non contengono le parole chiave esatte. Questo lo rende particolarmente potente per query in linguaggio naturale e risposte a domande.

  • Esempi di Richieste
  • Parametri del percorso
  • Parametri di Query
  • Formato di Risposta
  • Autenticazione
  • Risposte di Errore
  • Suggerimenti per l'Ottimizzazione della Ricerca
  • Finestre di Contesto
  • Soglia di Corrispondenza
  • Operazioni in Batch
  • Implementazione della Ricerca in Batch
  • Ottimizzazione delle Prestazioni per Operazioni in Batch