# Integrazione con LangChain

## 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`.

{% embed url="<https://python.langchain.com/docs/integrations/retrievers/rememberizer/>" %}

### 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](https://docs.rememberizer.ai/developer/registering-and-using-api-keys).

#### Installazione

Installa i pacchetti richiesti:

```bash
pip install langchain langchain_community
```

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

```bash
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`

   ```python
   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

   ```python
   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:

```python
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:

```python
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

* Guida concettuale [Retriever di LangChain](https://python.langchain.com/docs/concepts/#retrievers)
* Guide pratiche [Retriever di LangChain](https://python.langchain.com/docs/how_to/#retrievers)
* Documentazione [API di Rememberizer](https://docs.rememberizer.ai/developer/api-docs/)
* [Archivi vettoriali](https://docs.rememberizer.ai/developer/vector-stores) in Rememberizer
* [Creare un GPT di Rememberizer](/it/risorse-per-sviluppatori/integration-options/creating-a-rememberizer-gpt.md) - Un approccio alternativo per l'integrazione dell'IA


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.rememberizer.ai/it/risorse-per-sviluppatori/integration-options/langchain-integration.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.