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
  • Integrazione LangChain
  • Introduzione
  • Iniziare
  • Opzioni di Configurazione
  • Utilizzo di Base
  • Imposta la tua chiave API
  • Inizializza il recuperatore
  • Ottieni documenti pertinenti per una query
  • Visualizza il primo documento
  • Esempi Avanzati
  • Imposta le chiavi API
  • Inizializza il recuperatore e il modello linguistico
  • Crea una catena di QA di recupero
  • Fai una domanda
  • Stampa la risposta
  • Imposta le chiavi API
  • Inizializza i componenti
  • Crea la catena conversazionale
  • Esempio di conversazione
  • Crea recuperatori
  • Crea un insieme con punteggio ponderato
  • Risorse correlate
  1. Opzioni di integrazione

Integrazione con LangChain

Scopri come integrare Rememberizer come un recuperatore LangChain per fornire alla tua applicazione LangChain l'accesso a una potente ricerca nel database vettoriale.

PreviousCreazione di un Rememberizer GPTNextArchivi vettoriali

Last updated 24 days ago

Integrazione LangChain

Rememberizer si integra con LangChain attraverso la classe RememberizerRetriever, consentendoti di incorporare facilmente le capacità di ricerca semantica di Rememberizer nelle tue applicazioni alimentate da LangChain. Questa guida spiega come configurare e utilizzare questa integrazione per costruire applicazioni LLM avanzate con accesso alla tua base di conoscenza.

Introduzione

LangChain è un framework popolare per costruire applicazioni con modelli di linguaggio di grandi dimensioni (LLM). Integrando Rememberizer con LangChain, puoi:

  • Utilizzare la tua base di conoscenza Rememberizer nelle applicazioni RAG (Generazione Aumentata da Recupero)

  • Creare chatbot con accesso ai tuoi documenti e dati

  • Costruire sistemi di domande e risposte che sfruttano la tua conoscenza

  • Sviluppare agenti che possono cercare e ragionare sulle tue informazioni

L'integrazione è disponibile nel modulo langchain_community.retrievers.

Iniziare

Requisiti

Prima di iniziare, hai bisogno di:

  1. Un account Rememberizer con Conoscenza Comune creato

  2. Una chiave API per accedere alla tua Conoscenza Comune

  3. Un ambiente Python con LangChain installato

Installazione

Installa i pacchetti richiesti:

pip install langchain langchain_community

Se prevedi di utilizzare i modelli OpenAI (come mostrato negli esempi qui sotto):

pip install langchain_openai

Configurazione dell'autenticazione

Ci sono due modi per autenticare il RememberizerRetriever:

  1. Variabile d'ambiente: Imposta la variabile d'ambiente REMEMBERIZER_API_KEY

    import os
    os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"
  2. Parametro diretto: Passa la chiave API direttamente durante l'inizializzazione del recuperatore

    retriever = RememberizerRetriever(rememberizer_api_key="rem_ck_your_api_key")

Opzioni di Configurazione

La classe RememberizerRetriever accetta questi parametri:

Parametro
Tipo
Predefinito
Descrizione

top_k_results

int

10

Numero di documenti da restituire dalla ricerca

rememberizer_api_key

str

None

Chiave API per l'autenticazione (opzionale se impostata come variabile d'ambiente)

Dietro le quinte, il recuperatore effettua chiamate API all'endpoint di ricerca di Rememberizer con parametri configurabili aggiuntivi:

Parametro Avanzato
Descrizione

prev_chunks

Numero di chunk prima del chunk corrispondente da includere (predefinito: 2)

next_chunks

Numero di chunk dopo il chunk corrispondente da includere (predefinito: 2)

return_full_content

Se restituire il contenuto completo del documento (predefinito: true)

Utilizzo di Base

Ecco un semplice esempio di recupero di documenti da Rememberizer utilizzando LangChain:

import os
from langchain_community.retrievers import RememberizerRetriever

Imposta la tua chiave API

os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"

Inizializza il recuperatore

retriever = RememberizerRetriever(top_k_results=5)

Ottieni documenti pertinenti per una query

docs = retriever.get_relevant_documents(query="Come funzionano gli embedding vettoriali?")

Visualizza il primo documento

if docs: print(f"Documento: {docs[0].metadata['name']}") print(f"Contenuto: {docs[0].page_content[:200]}...")


### Comprendere la Struttura del Documento

Ogni documento restituito dal recuperatore ha:

- `page_content`: Il contenuto testuale del frammento di documento corrispondente
- `metadata`: Informazioni aggiuntive sul documento

Esempio di struttura dei metadati:

```python
{
  'id': 13646493,
  'document_id': '17s3LlMbpkTk0ikvGwV0iLMCj-MNubIaP',
  'name': 'What is a large language model (LLM)_ _ Cloudflare.pdf',
  'type': 'application/pdf',
  'path': '/langchain/What is a large language model (LLM)_ _ Cloudflare.pdf',
  'url': 'https://drive.google.com/file/d/17s3LlMbpkTk0ikvGwV0iLMCj-MNubIaP/view',
  'size': 337089,
  'created_time': '',
  'modified_time': '',
  'indexed_on': '2024-04-04T03:36:28.886170Z',
  'integration': {'id': 347, 'integration_type': 'google_drive'}
}

Esempi Avanzati

Costruire un Sistema di Domande e Risposte RAG

Questo esempio crea un sistema di domande e risposte che recupera informazioni da Rememberizer e utilizza GPT-3.5 per formulare risposte:

import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI

Imposta le chiavi API

os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key" os.environ["OPENAI_API_KEY"] = "your_openai_api_key"

Inizializza il recuperatore e il modello linguistico

retriever = RememberizerRetriever(top_k_results=5) llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)

Crea una catena di QA di recupero

qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", # Metodo più semplice - basta inserire tutti i documenti nel prompt retriever=retriever, return_source_documents=True )

Fai una domanda

response = qa_chain.invoke({"query": "Che cos'è RAG nel contesto dell'IA?"})

Stampa la risposta

print(f"Risposta: {response['result']}") print("\nFonti:") for idx, doc in enumerate(response['source_documents']): print(f"{idx+1}. {doc.metadata['name']}")


### Costruire un Agente Conversazionale con Memoria

Questo esempio crea un agente conversazionale che può mantenere la cronologia delle conversazioni:

```python
import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI

Imposta le chiavi API

os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key" os.environ["OPENAI_API_KEY"] = "your_openai_api_key"

Inizializza i componenti

retriever = RememberizerRetriever(top_k_results=5) llm = ChatOpenAI(model_name="gpt-3.5-turbo") memory = ConversationBufferMemory( memory_key="chat_history", return_messages=True )

Crea la catena conversazionale

conversation = ConversationalRetrievalChain.from_llm( llm=llm, retriever=retriever, memory=memory )

Esempio di conversazione

questions = [ "Che cos'è RAG?", "Come lo utilizzano i modelli di linguaggio di grandi dimensioni?", "Quali sono i limiti di questo approccio?", ]

for question in questions: response = conversation.invoke({"question": question}) print(f"Domanda: {question}") print(f"Risposta: {response['answer']}\n")


## Migliori Pratiche

### Ottimizzazione delle Prestazioni di Recupero

1. **Essere specifici con le query**: Query più specifiche di solito producono risultati migliori
2. **Regolare `top_k_results`**: Iniziare con 3-5 risultati e regolare in base alle esigenze dell'applicazione
3. **Utilizzare finestre di contesto**: Il recuperatore include automaticamente il contesto attorno ai frammenti corrispondenti

### Considerazioni sulla Sicurezza

1. **Proteggi la tua chiave API**: Conservala in modo sicuro utilizzando variabili di ambiente o strumenti di gestione dei segreti
2. **Crea chiavi dedicate**: Crea chiavi API separate per diverse applicazioni
3. **Ruota le chiavi regolarmente**: Genera periodicamente nuove chiavi e dismetti quelle vecchie

### Modelli di integrazione

1. **Elaborazione pre-retrieval**: Considera di preprocessare le query degli utenti per migliorare la rilevanza della ricerca
2. **Filtraggio post-retrieval**: Filtra o classifica i documenti recuperati prima di passarli al LLM
3. **Ricerca ibrida**: Combina Rememberizer con altri recuperatori utilizzando `EnsembleRetriever`

```python
from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import RememberizerRetriever, WebResearchRetriever

Crea recuperatori

rememberizer_retriever = RememberizerRetriever(top_k_results=3) web_retriever = WebResearchRetriever(...) # Configura un altro recuperatore

Crea un insieme con punteggio ponderato

ensemble_retriever = EnsembleRetriever( retrievers=[rememberizer_retriever, web_retriever], weights=[0.7, 0.3] # I risultati di Rememberizer hanno un peso maggiore )


## Risoluzione dei problemi

### Problemi comuni

1. **Errori di autenticazione**: Verifica che la tua chiave API sia corretta e configurata correttamente
2. **Nessun risultato restituito**: Assicurati che il tuo Common Knowledge contenga informazioni pertinenti
3. **Limitazione della velocità**: Fai attenzione ai limiti di velocità dell'API per applicazioni ad alto volume

### Suggerimenti per il Debug

- Imposta la modalità di debug di LangChain per vedere le chiamate API dettagliate:
  ```python
  import langchain
  langchain.debug = True
  • Esamina i risultati di ricerca grezzi prima di passarli a LLM per identificare problemi di recupero

Risorse correlate

Per istruzioni dettagliate su come creare Conoscenza Comune e generare una chiave API, vedere .

Guida concettuale

Guide pratiche

Documentazione

in Rememberizer

- Un approccio alternativo per l'integrazione dell'IA

Registrazione e Utilizzo delle Chiavi API
Retriever di LangChain
Retriever di LangChain
API di Rememberizer
Archivi vettoriali
Creare un GPT di Rememberizer
Rememberizer | 🦜️🔗 LangChain
Logo