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.
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:
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_communitySe prevedi di utilizzare i modelli OpenAI (come mostrato negli esempi qui sotto):
pip install langchain_openaiConfigurazione dell'autenticazione
Ci sono due modi per autenticare il RememberizerRetriever:
Variabile d'ambiente: Imposta la variabile d'ambiente
REMEMBERIZER_API_KEYimport 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:
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:
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 RememberizerRetrieverImposta 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 ChatOpenAIImposta 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 ChatOpenAIImposta 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, WebResearchRetrieverCrea 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 = TrueEsamina 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
Last updated