RegistrazioneIscrizioneContattaci

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.

LogoRememberizer | 🦜️🔗 LangChain

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

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:

  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

PreviousCreazione di un Rememberizer GPTNextArchivi vettoriali

Last updated