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.

https://python.langchain.com/docs/integrations/retrievers/rememberizer/

Iniziare¶

Requisiti¶

Prima di iniziare, hai bisogno di:

Un account Rememberizer con Conoscenza Comune creato
Una chiave API per accedere alla tua Conoscenza Comune
Un ambiente Python con LangChain installato

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

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:

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

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

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¶

Errori di autenticazione: Verifica che la tua chiave API sia corretta e configurata correttamente
Nessun risultato restituito: Assicurati che il tuo Common Knowledge contenga informazioni pertinenti
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¶

Guida concettuale Retriever di LangChain
Guide pratiche Retriever di LangChain
Documentazione API di Rememberizer
Archivi vettoriali in Rememberizer
Creare un GPT di Rememberizer - Un approccio alternativo per l'integrazione dell'IA