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

# Generowanie wspomagane wyszukiwaniem

## Omówienie

**Retrieval-Augmented Generation (RAG)** pozwala agentowi korzystać z dużych baz wiedzy podczas rozmów. Zamiast ładować całe dokumenty do okna kontekstu, RAG pobiera tylko informacje najbardziej istotne dla każdego zapytania użytkownika, dzięki czemu agent może:

* Korzystać z dużo większych baz wiedzy, niż zmieściłoby się w prompcie
* Udzielać dokładniejszych odpowiedzi opartych na wiedzy
* Ograniczać halucynacje dzięki odwoływaniu się do materiałów źródłowych
* Skalować bazę wiedzy bez tworzenia wielu wyspecjalizowanych agentów

RAG idealnie sprawdza się w agentach, które muszą odwoływać się do dużych dokumentów, instrukcji technicznych lub rozbudowanych
baz wiedzy, przekraczających limity okna kontekstu tradycyjnego promptowania.
RAG nieznacznie wydłuża czas odpowiedzi agenta, o około 250 ms.

> **Note**
>
> Ten film nagrano we wcześniejszej wersji panelu. Kroki konfiguracji RAG pozostały
> bez zmian, ale niektóre elementy interfejsu mogą wyglądać inaczej.

## Jak działa RAG

Gdy RAG jest włączony, agent przetwarza zapytania użytkownika w tych krokach:

1. **Przetwarzanie zapytania**: Pytanie użytkownika jest analizowane i przeformułowywane, by zoptymalizować wyszukiwanie.
2. **Tworzenie embeddingu**: Przetworzone zapytanie jest konwertowane na embedding wektorowy reprezentujący pytanie użytkownika.
3. **Wyszukiwanie**: System znajduje najbardziej podobne semantycznie treści w bazie wiedzy.
4. **Generowanie odpowiedzi**: Agent tworzy odpowiedź, korzystając zarówno z kontekstu rozmowy, jak i pobranych informacji.

Ten proces zapewnia przekazanie do LLM informacji istotnych dla zapytania użytkownika, aby wygenerować zgodną z faktami odpowiedź.

## Przewodnik

### Wymagania wstępne

* [Konto ElevenLabs](https://elevenlabs.io)
* Skonfigurowany [agent ElevenLabs](/docs/pl/eleven-agents/quickstart)
* Co najmniej jeden dokument dodany do bazy wiedzy agenta

### Włącz RAG dla agenta

#### Aktualizacja w panelu

W ustawieniach agenta otwórz **Knowledge Base** i wybierz kartę **Retrieval**. W sekcji **Retrieval mode** wybierz **Every turn**, aby przeszukiwać bazę wiedzy przy każdej turze, albo **On demand**, aby agent wyszukiwał tylko wtedy, gdy uzna to za potrzebne. **Prompt only** wyłącza wyszukiwanie.

W sekcji **Semantic search** skonfiguruj model embeddingu, limit odległości wektorowej i liczbę kandydatów, a w **Retrieval limits** — limity znaków i fragmentów.

#### Aktualizacja przez CLI

#### Pobierz konfigurację agenta

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

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

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

#### Prześlij zmiany

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

#### Aktualizacja przez API

Pełny kod, który uruchamia indeksowanie RAG dokumentu i aktualizuje konfigurację agenta, znajdziesz w sekcji [implementacja API](#api-implementation) poniżej.

### Indeksowanie bazy wiedzy

Każdy dokument w bazie wiedzy musi zostać zindeksowany, zanim będzie można użyć go z RAG. Ten
proces odbywa się automatycznie, gdy dokument zostanie dodany do agenta z włączonym RAG.

> **Info**
>
> Indeksowanie dużych dokumentów może potrwać kilka minut. Status indeksowania sprawdzisz na
> liście bazy wiedzy.

### Skonfiguruj tryby użycia dokumentów (opcjonalnie)

Dla każdego dokumentu w bazie wiedzy możesz wybrać sposób jego użycia:

* **Auto (domyślnie)**: Dokument jest pobierany tylko wtedy, gdy jest istotny dla zapytania
* **Prompt**: Dokument jest zawsze dołączany do promptu systemowego, niezależnie od istotności

![Opcje trybu użycia dokumentu w bazie wiedzy](/docs/_fern-img/265aa612b4ad2da915b617552312b47c965892559b2a8615ecb42551763de4a5.webp)

> **Warning**
>
> Ustawienie zbyt wielu dokumentów w trybie „Prompt” może przekroczyć limity kontekstu. Używaj tej opcji oszczędnie
> dla kluczowych informacji.

### Przetestuj agenta z włączonym RAG

Po zapisaniu konfiguracji przetestuj agenta, zadając pytania związane z bazą wiedzy. Agent powinien teraz pobierać i przywoływać konkretne informacje z dokumentów.

## Limity użycia

Aby zapewnić sprawiedliwy podział zasobów, ElevenLabs stosuje limity łącznego rozmiaru dokumentów, które można indeksować dla RAG w każdym obszarze roboczym, zależnie od planu subskrypcji.

Limity są następujące:

| Plan subskrypcji | Limit łącznego rozmiaru dokumentów | Uwagi                                                  |
| :--------------- | :--------------------------------- | :----------------------------------------------------- |
| Free             | 1 MB                               | Indeksy mogą zostać usunięte po okresie nieaktywności. |
| Starter          | 2 MB                               |                                                        |
| Creator          | 20 MB                              |                                                        |
| Pro              | 100 MB                             |                                                        |
| Scale            | 500 MB                             |                                                        |
| Business         | 1 GB                               |                                                        |
| Enterprise       | 1 GB                               | Wyższe limity są dostępne zależnie od planu i umowy.   |

**Uwaga:**

* Te limity dotyczą łącznego **oryginalnego rozmiaru plików** dokumentów indeksowanych dla RAG, a nie wewnętrznego rozmiaru magazynu indeksu RAG (który może być znacznie większy).
* Dokumentów mniejszych niż 500 bajtów nie można indeksować dla RAG — zamiast tego będą automatycznie używane w prompcie.

## Implementacja API

RAG możesz też wdrożyć przez [API](/docs/pl/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));
```