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

# Geração aumentada por recuperação

## Visão geral

A **Geração Aumentada por Recuperação (RAG)** permite que seu agente acesse e use grandes bases de conhecimento durante as conversas. Em vez de carregar documentos inteiros na janela de contexto, o RAG recupera apenas as informações mais relevantes para cada consulta do usuário, permitindo que seu agente:

* Acesse bases de conhecimento muito maiores do que caberiam em um prompt
* Forneça respostas mais precisas e embasadas no conhecimento
* Reduza alucinações ao consultar o material de origem
* Amplie o conhecimento sem criar vários agentes especializados

O RAG é ideal para agentes que precisam consultar documentos extensos, manuais técnicos ou grandes
bases de conhecimento que excederiam os limites da janela de contexto dos prompts tradicionais.
O RAG adiciona uma pequena latência ao tempo de resposta do seu agente, cerca de 250 ms.

> **Note**
>
> Este vídeo foi gravado com uma versão anterior do painel. As etapas de configuração do RAG
> continuam as mesmas, mas alguns elementos da interface podem parecer diferentes.

## Como o RAG funciona

Quando o RAG está ativado, seu agente processa as consultas dos usuários seguindo estas etapas:

1. **Processamento da consulta**: A pergunta do usuário é analisada e reformulada para uma recuperação ideal.
2. **Geração de embeddings**: A consulta processada é convertida em um embedding vetorial que representa a pergunta do usuário.
3. **Recuperação**: O sistema encontra o conteúdo semanticamente mais semelhante na sua base de conhecimento.
4. **Geração de resposta**: O agente gera uma resposta usando tanto o contexto da conversa quanto as informações recuperadas.

Esse processo garante que informações relevantes para a consulta do usuário sejam enviadas ao LLM para gerar uma resposta factualmente correta.

## Guia

### Pré-requisitos

* Uma [conta da ElevenLabs](https://elevenlabs.io)
* Um [Agente Conversacional](/docs/pt/eleven-agents/quickstart) da ElevenLabs configurado
* Pelo menos um documento adicionado à base de conhecimento do seu agente

### Ative o RAG para seu agente

#### Atualizar pelo painel

Nas configurações do seu agente, acesse a seção **Base de conhecimento** e ative a opção **Usar RAG**. Configure o modelo de embedding, o máximo de trechos de documentos e a distância vetorial máxima na aba **Avançado**, conforme necessário.

![Opções de configuração do RAG, incluindo a seleção do modelo de embedding](/docs/_fern-img/6e8a6273d26090d92a2ed237ffbc488f44e5e9a408aca6511afa94461d177c86.webp)

#### Atualizar pela CLI

#### Baixe a configuração do agente

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

#### Edite \`agent_configs/\<agent-name>.json\`

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

#### Envie suas alterações

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

#### Atualizar pela API

Consulte a seção [Implementação da API](#api-implementation) abaixo para ver o código completo que aciona a indexação RAG em um documento e atualiza a configuração do agente.

### Indexação da base de conhecimento

Cada documento na sua base de conhecimento precisa ser indexado antes de poder ser usado com o RAG. Esse
processo ocorre automaticamente quando um documento é adicionado a um agente com RAG ativado.

> **Info**
>
> A indexação pode levar alguns minutos para documentos grandes. Você pode verificar o status da indexação na
> lista da base de conhecimento.

### Configure os modos de uso dos documentos (opcional)

Para cada documento na sua base de conhecimento, você pode escolher como ele será usado:

* **Automático (padrão)**: O documento só é recuperado quando é relevante para a consulta
* **Prompt**: O documento é sempre incluído no prompt do sistema, independentemente da relevância

![Opções de modo de uso de documentos na base de conhecimento](/docs/_fern-img/265aa612b4ad2da915b617552312b47c965892559b2a8615ecb42551763de4a5.webp)

> **Warning**
>
> Definir muitos documentos no modo "Prompt" pode exceder os limites de contexto. Use essa opção com moderação
> para informações essenciais.

### Teste seu agente com RAG ativado

Depois de salvar sua configuração, teste seu agente fazendo perguntas relacionadas à sua base de conhecimento. Agora, o agente deve conseguir recuperar e consultar informações específicas dos seus documentos.

## Limites de uso

Para garantir uma alocação justa de recursos, a ElevenLabs aplica limites ao tamanho total dos documentos que podem ser indexados para RAG por espaço de trabalho, com base no nível de assinatura.

Os limites são os seguintes:

| Nível de assinatura | Limite total de tamanho dos documentos | Observações                                                |
| :------------------ | :------------------------------------- | :--------------------------------------------------------- |
| Gratuito            | 1 MB                                   | Os índices podem ser excluídos após um período inativo.    |
| Starter             | 2 MB                                   |                                                            |
| Creator             | 20 MB                                  |                                                            |
| Pro                 | 100 MB                                 |                                                            |
| Scale               | 500 MB                                 |                                                            |
| Business            | 1 GB                                   |                                                            |
| Enterprise          | 1 GB                                   | Limites maiores disponíveis conforme o nível e o contrato. |

**Observação:**

* Esses limites se aplicam ao **tamanho original do arquivo** dos documentos indexados para RAG, e não ao tamanho de armazenamento interno do próprio índice RAG (que pode ser significativamente maior).
* Documentos com menos de 500 bytes não podem ser indexados para RAG e serão usados automaticamente no prompt.

## Implementação da API

Você também pode implementar RAG pela [API](/docs/pt/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));
```