> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Generazione aumentata dal recupero

## Panoramica

**Retrieval-Augmented Generation (RAG)** consente al tuo agente di accedere e utilizzare grandi knowledge base durante le conversazioni. Anziché caricare documenti interi nella finestra di contesto, RAG recupera solo le informazioni più pertinenti per ogni query dell'utente, consentendo al tuo agente di:

* Accedere a knowledge base molto più grandi di quanto potrebbe contenere un prompt
* Fornire risposte più accurate e basate sulla knowledge base
* Ridurre le allucinazioni facendo riferimento al materiale sorgente
* Ampliare la knowledge base senza creare più agenti specializzati

RAG è ideale per gli agenti che devono fare riferimento a documenti di grandi dimensioni, manuali tecnici o knowledge base
estese che supererebbero i limiti della finestra di contesto del prompting tradizionale.
RAG aggiunge una leggera latenza al tempo di risposta dell'agente, circa 250 ms.

> **Note**
>
> Questo video è stato registrato con una versione precedente della dashboard. I passaggi di configurazione di RAG sono
> invariati, ma alcuni elementi dell'interfaccia potrebbero apparire diversi.

## Come funziona RAG

Quando RAG è abilitato, il tuo agente elabora le query degli utenti seguendo questi passaggi:

1. **Elaborazione della query**: la domanda dell'utente viene analizzata e riformulata per un recupero ottimale.
2. **Generazione dell'embedding**: la query elaborata viene convertita in un embedding vettoriale che rappresenta la domanda dell'utente.
3. **Recupero**: il sistema trova i contenuti semanticamente più simili nella tua knowledge base.
4. **Generazione della risposta**: l'agente genera una risposta usando sia il contesto della conversazione sia le informazioni recuperate.

Questo processo garantisce che le informazioni pertinenti alla query dell'utente vengano passate all'LLM per generare una risposta corretta dal punto di vista fattuale.

## Guida

### Prerequisiti

* Un [account ElevenLabs](https://elevenlabs.io)
* Un [agente conversazionale](/docs/it/eleven-agents/quickstart) ElevenLabs configurato
* Almeno un documento aggiunto alla knowledge base dell'agente

### Abilita RAG per il tuo agente

#### Aggiorna dalla dashboard

Nelle impostazioni dell'agente, vai alla sezione **Knowledge Base** e attiva l'opzione **Use RAG**. Configura il modello di embedding, il numero massimo di chunk di documenti e la distanza vettoriale massima nella scheda **Advanced**, secondo necessità.

![Opzioni di configurazione RAG, inclusa la selezione del modello di embedding](/docs/_fern-img/6e8a6273d26090d92a2ed237ffbc488f44e5e9a408aca6511afa94461d177c86.webp)

#### Aggiorna tramite CLI

#### Recupera la configurazione dell'agente

```bash
elevenlabs agents pull --agent "<agent-name>"
```

#### Modifica \`agent\_configs/\<agent-name>.json\`

Imposta `conversation_config.agent.prompt.rag`:

```json
{
  "conversation_config": {
    "agent": {
      "prompt": {
        "rag": {
          "enabled": true,
          "embedding_model": "e5_mistral_7b_instruct",
          "max_vector_distance": 0.6,
          "max_documents_length": 50000,
          "max_retrieved_rag_chunks_count": 20
        }
      }
    }
  }
}
```

#### Invia le modifiche

```bash
elevenlabs agents push --agent "<agent-name>"
```

#### Aggiorna tramite API

Consulta la sezione [implementazione API](#api-implementation) qui sotto per il codice completo che attiva l'indicizzazione RAG di un documento e aggiorna la configurazione dell'agente.

### Indicizzazione della knowledge base

Ogni documento della knowledge base deve essere indicizzato prima di poter essere utilizzato con RAG. Questo
processo avviene automaticamente quando un documento viene aggiunto a un agente con RAG abilitato.

> **Info**
>
> L'indicizzazione di documenti di grandi dimensioni può richiedere alcuni minuti. Puoi controllarne lo stato nell'elenco della
> knowledge base.

### Configura le modalità di utilizzo dei documenti (facoltativo)

Per ogni documento della knowledge base, puoi scegliere come utilizzarlo:

* **Auto (predefinito)**: il documento viene recuperato solo quando è pertinente alla query
* **Prompt**: il documento viene sempre incluso nel prompt di sistema, indipendentemente dalla pertinenza

![Opzioni della modalità di utilizzo dei documenti nella knowledge base](/docs/_fern-img/265aa612b4ad2da915b617552312b47c965892559b2a8615ecb42551763de4a5.webp)

> **Warning**
>
> Impostare troppi documenti in modalità "Prompt" potrebbe superare i limiti di contesto. Usa questa opzione con parsimonia
> per le informazioni critiche.

### Testa il tuo agente con RAG abilitato

Dopo aver salvato la configurazione, testa il tuo agente ponendo domande relative alla knowledge base. Ora l'agente dovrebbe essere in grado di recuperare e fare riferimento a informazioni specifiche nei documenti.

## Limiti di utilizzo

Per garantire un'allocazione equa delle risorse, ElevenLabs applica limiti alla dimensione totale dei documenti che possono essere indicizzati per RAG in ogni workspace, in base al piano di abbonamento.

I limiti sono i seguenti:

| Piano di abbonamento | Limite dimensione totale documenti | Note                                                           |
| :------------------- | :--------------------------------- | :------------------------------------------------------------- |
| Free                 | 1MB                                | Gli indici possono essere eliminati dopo inattività.           |
| Starter              | 2MB                                |                                                                |
| Creator              | 20MB                               |                                                                |
| Pro                  | 100MB                              |                                                                |
| Scale                | 500MB                              |                                                                |
| Business             | 1GB                                |                                                                |
| Enterprise           | 1GB                                | Limiti più elevati disponibili in base al piano e all'accordo. |

**Nota:**

* Questi limiti si applicano alla **dimensione originale del file** totale dei documenti indicizzati per RAG, non alla dimensione di archiviazione interna dell'indice RAG stesso, che può essere significativamente maggiore.
* I documenti più piccoli di 500 byte non possono essere indicizzati per RAG e verranno invece utilizzati automaticamente nel prompt.

## Implementazione API

Puoi anche implementare RAG tramite l'[API](/docs/it/api-reference/knowledge-base/compute-rag-index):

```python
from elevenlabs import ElevenLabs
import time

# Initialize the ElevenLabs client
elevenlabs = ElevenLabs(api_key="your-api-key")

# First, index a document for RAG
document_id = "your-document-id"
embedding_model = "e5_mistral_7b_instruct"

# Trigger RAG indexing
response = elevenlabs.conversational_ai.knowledge_base.document.compute_rag_index(
    documentation_id=document_id,
    model=embedding_model
)

# Check indexing status
while response.status not in ["SUCCEEDED", "FAILED"]:
    time.sleep(5)  # Wait 5 seconds before checking status again
    response = elevenlabs.conversational_ai.knowledge_base.document.compute_rag_index(
        documentation_id=document_id,
        model=embedding_model
    )

# Then update agent configuration to use RAG
agent_id = "agent_7101k5zvyjhmfg983brhmhkd98n6"

# Get the current agent configuration
agent_config = elevenlabs.conversational_ai.agents.get(agent_id=agent_id)

# Enable RAG in the agent configuration
agent_config.agent.prompt.rag = {
    "enabled": True,
    "embedding_model": "e5_mistral_7b_instruct",
    "max_documents_length": 10000
}

# Update document usage mode if needed
for i, doc in enumerate(agent_config.agent.prompt.knowledge_base):
    if doc.id == document_id:
        agent_config.agent.prompt.knowledge_base[i].usage_mode = "auto"

# Update the agent configuration
elevenlabs.conversational_ai.agents.update(
    agent_id=agent_id,
    conversation_config=agent_config.agent
)

```

```javascript
// First, index a document for RAG
async function enableRAG(documentId, agentId, apiKey) {
  try {
    // Initialize the ElevenLabs client
    const { ElevenLabsClient } = require("@elevenlabs/elevenlabs-js");
    const elevenlabs = new ElevenLabsClient({
      apiKey: apiKey,
    });

    // Start document indexing for RAG
    let response = await elevenlabs.conversationalAi.knowledgeBase.document.computeRagIndex(
      documentId,
      {
        model: "e5_mistral_7b_instruct",
      }
    );

    // Check indexing status until completion
    while (response.status !== "SUCCEEDED" && response.status !== "FAILED") {
      await new Promise((resolve) => setTimeout(resolve, 5000)); // Wait 5 seconds
      response = await elevenlabs.conversationalAi.knowledgeBase.document.computeRagIndex(
        documentId,
        {
          model: "e5_mistral_7b_instruct",
        }
      );
    }

    if (response.status === "FAILED") {
      throw new Error("RAG indexing failed");
    }

    // Get current agent configuration
    const agentConfig = await elevenlabs.conversationalAi.agents.get(agentId);

    // Enable RAG in the agent configuration
    const updatedConfig = {
      conversation_config: {
        ...agentConfig.agent,
        prompt: {
          ...agentConfig.agent.prompt,
          rag: {
            enabled: true,
            embedding_model: "e5_mistral_7b_instruct",
            max_documents_length: 10000,
          },
        },
      },
    };

    // Update document usage mode if needed
    if (agentConfig.agent.prompt.knowledge_base) {
      agentConfig.agent.prompt.knowledge_base.forEach((doc, index) => {
        if (doc.id === documentId) {
          updatedConfig.conversation_config.prompt.knowledge_base[index].usage_mode = "auto";
        }
      });
    }

    // Update the agent configuration
    await elevenlabs.conversationalAi.agents.update(agentId, updatedConfig);

    console.log("RAG configuration updated successfully");
    return true;
  } catch (error) {
    console.error("Error configuring RAG:", error);
    throw error;
  }
}

// Example usage
// enableRAG('your-document-id', 'agent_7101k5zvyjhmfg983brhmhkd98n6', 'your-api-key')
//   .then(() => console.log('RAG setup complete'))
//   .catch(err => console.error('Error:', err));
```