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

# Retrieval-Augmented Generation

## Overzicht

**Retrieval-Augmented Generation (RAG)** geeft je agent toegang tot grote kennisbanken die deze tijdens gesprekken kan gebruiken. In plaats van volledige documenten in het contextvenster te laden, haalt RAG alleen de meest relevante informatie op voor elke gebruikersvraag. Hierdoor kan je agent:

* Kennisbanken raadplegen die veel groter zijn dan in een prompt passen
* Nauwkeurigere, op kennis gebaseerde antwoorden geven
* Hallucinaties verminderen door naar bronmateriaal te verwijzen
* Kennis opschalen zonder meerdere gespecialiseerde agents te maken

RAG is ideaal voor agents die grote documenten, technische handleidingen of uitgebreide
kennisbanken moeten raadplegen die de limieten van het contextvenster van traditionele prompting zouden overschrijden.
RAG voegt een kleine vertraging van ongeveer 250 ms toe aan de reactietijd van je agent.

> **Note**
>
> Deze video is opgenomen met een eerdere versie van het dashboard. De configuratiestappen voor RAG zijn
> ongewijzigd, maar sommige interface-elementen kunnen er anders uitzien.

## Hoe RAG werkt

Wanneer RAG is ingeschakeld, verwerkt je agent gebruikersvragen volgens deze stappen:

1. **Queryverwerking**: De vraag van de gebruiker wordt geanalyseerd en geherformuleerd voor optimale retrieval.
2. **Embeddinggeneratie**: De verwerkte query wordt omgezet in een vector-embedding die de vraag van de gebruiker weergeeft.
3. **Retrieval**: Het systeem zoekt de semantisch meest vergelijkbare content in je kennisbank.
4. **Antwoordgeneratie**: De agent genereert een antwoord met zowel de gesprekscontext als de opgehaalde informatie.

Dit proces zorgt ervoor dat informatie die relevant is voor de vraag van de gebruiker aan de LLM wordt doorgegeven om een feitelijk juist antwoord te genereren.

## Handleiding

### Vereisten

* Een [ElevenLabs-account](https://elevenlabs.io)
* Een geconfigureerde ElevenLabs-agent ([maak er hier een](/docs/nl/eleven-agents/quickstart))
* Minstens één document toegevoegd aan de kennisbank van je agent

### Schakel RAG in voor je agent

#### Bijwerken via het dashboard

Ga in de instellingen van je agent naar de sectie **Knowledge Base** en schakel de optie **Use RAG** in. Configureer naar behoefte het embeddingmodel, het maximumaantal documentchunks en de maximale vectorafstand op het tabblad **Advanced**.

![RAG-configuratieopties, waaronder selectie van het embeddingmodel](/docs/_fern-img/6e8a6273d26090d92a2ed237ffbc488f44e5e9a408aca6511afa94461d177c86.webp)

#### Bijwerken via de CLI

#### Haal de agentconfiguratie op

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

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

Stel `conversation_config.agent.prompt.rag` in:

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

#### Push je wijzigingen

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

#### Bijwerken via de API

Raadpleeg de sectie [API-implementatie](#api-implementation) hieronder voor volledige code die RAG-indexering voor een document start en de agentconfiguratie bijwerkt.

### Kennisbankindexering

Elk document in je kennisbank moet worden geïndexeerd voordat het met RAG kan worden gebruikt. Dit
gebeurt automatisch wanneer een document wordt toegevoegd aan een agent waarvoor RAG is ingeschakeld.

> **Info**
>
> Het indexeren van grote documenten kan enkele minuten duren. Je kunt de indexeringsstatus in de
> kennisbanklijst controleren.

### Modi voor documentgebruik configureren (optioneel)

Voor elk document in je kennisbank kun je kiezen hoe het wordt gebruikt:

* **Auto (standaard)**: Het document wordt alleen opgehaald wanneer het relevant is voor de query
* **Prompt**: Het document wordt altijd opgenomen in de systeemprompt, ongeacht de relevantie

![Opties voor de gebruiksmodus van documenten in de kennisbank](/docs/_fern-img/265aa612b4ad2da915b617552312b47c965892559b2a8615ecb42551763de4a5.webp)

> **Warning**
>
> Te veel documenten instellen op de modus "Prompt" kan contextlimieten overschrijden. Gebruik deze optie
> spaarzaam voor kritieke informatie.

### Test je agent met RAG ingeschakeld

Test je agent na het opslaan van je configuratie door vragen te stellen die verband houden met je kennisbank. Je agent moet nu specifieke informatie uit je documenten kunnen ophalen en ernaar kunnen verwijzen.

## Gebruiksbeperkingen

Om een eerlijke verdeling van resources te waarborgen, hanteert ElevenLabs limieten voor de totale grootte van documenten die per workspace voor RAG kunnen worden geïndexeerd, op basis van het abonnement.

De limieten zijn als volgt:

| Abonnement | Limiet voor totale documentgrootte | Opmerkingen                                                       |
| :--------- | :--------------------------------- | :---------------------------------------------------------------- |
| Free       | 1 MB                               | Indexen kunnen na inactiviteit worden verwijderd.                 |
| Starter    | 2 MB                               |                                                                   |
| Creator    | 20 MB                              |                                                                   |
| Pro        | 100 MB                             |                                                                   |
| Scale      | 500 MB                             |                                                                   |
| Business   | 1 GB                               |                                                                   |
| Enterprise | 1 GB                               | Hogere limieten mogelijk op basis van abonnement en overeenkomst. |

**Opmerking:**

* Deze limieten gelden voor de totale **oorspronkelijke bestandsgrootte** van documenten die voor RAG zijn geïndexeerd, niet voor de interne opslaggrootte van de RAG-index zelf (die aanzienlijk groter kan zijn).
* Documenten kleiner dan 500 bytes kunnen niet voor RAG worden geïndexeerd en worden in plaats daarvan automatisch in de prompt gebruikt.

## API-implementatie

Je kunt RAG ook implementeren via de [API](/docs/nl/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));
```