> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pawa-ai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# RAG

> Pawa AI APIs make it easy to build Retrieval-Augmented Generation (RAG) systems out of the box, without unnecessary complexity or technical jargon and at low cost.

### RAG (Retrieval-Augmented Generation)

Retrieval-Augmented Generation, or **RAG**, is a technique that combines the power of language models with your own data sources. This approach ensures that AI responses are both **relevant** and **accurate**, even when the model has not been trained on your specific data.

<Card title="Build a RAG powered Apps, with Pawa AI" icon="code" href="https://builder.pawa-ai.com/dashboard?page=home" img="/images/RAG.png" cta="Get Started">
  Register to Pawa AI, create a knowledge by uploading documents of your favorite, copy the kb-reference-id and send RAG requests.
</Card>

#### Why RAG is Needed

Language models are typically trained on large amounts of publicly available internet data. While powerful, this training has two main limitations:

1. **Hallucinations (false answers):**\
   Models may generate responses that sound correct but are factually inaccurate, especially when asked about data outside their training set.

2. **Missing internal or private knowledge:**\
   Your business or organization may rely on proprietary or domain-specific data that is not included in public training datasets.\
   Examples:
   * Internal company policies
   * Proprietary research papers
   * Product manuals
   * Customer support knowledge base

Without access to this data, the model cannot provide reliable answers.

#### How RAG Solves This Problem

RAG reduces hallucinations and improves accuracy by retrieving **relevant, trusted information** from your data sources at the time of the request, and then passing that context along with the query to the model.

This means:

* The model has the **latest, most relevant information** available.
* Responses are **grounded in your data** instead of relying solely on general training.
* You can maintain **accuracy and trust** in critical use cases.

> **RAG enables you to enhance the model with your own knowledge base**, ensuring that it can answer domain-specific questions correctly and reliably. With Pawa AI APIs, you can implement RAG systems easily, without dealing with unnecessary complexity.

#### Implementing RAG With Pawa AI in Your System

To implement RAG, you first need a **Knowledge Base (KB)** — think of it as your private reference library for the Pawa model.

Traditionally, creating a KB involves setting up complex pipelines for **extraction, chunking, embeddings, and retrieval**. Each step needs to be efficient; otherwise, you risk retrieving irrelevant sources and producing incorrect answers.

With Pawa AI, we’ve simplified this process. Our platform automatically handles extraction, chunking, and embedding using our models. Once complete, you’ll receive a **Knowledge Base Reference ID**, which you can pass as a parameter during chat requests.

The Pawa chat API then incorporates your private reference source using **semantic retrieval**, ensuring that the model answers accurately based on your custom data.

***

#### Step 1: Create a Pawa AI Account

* Sign up for a Pawa AI account.
* Verify your email and log in as a **Builder**.

#### Step 2: Create a Knowledge Base

* Navigate to the **Storage** page in your Builder Dashboard.
* Click **Create Vector Store** under the Vectors section.
* Upload files in supported formats: `.pdf`, `.docx`, `.txt`, `.mp3`, `.wav`, `.pptx`, `.xlsx`, `.png`, `.jpg`, or provide URLs to your websites or online data.
* Copy the generated **Knowledge Base Reference ID**.   Eg. `kb-930d251e-8a8b-4ba9-bae1-5fceb47bd654`

***

#### Step 3: Make Your RAG-Based API Request

* Use the Knowledge Base Reference ID in your chat API request.
* The model will retrieve relevant information from your KB to generate grounded, context-aware responses.

```bash theme={null}
curl --request POST \
     --url https://api.pawa-ai.com/v1/chat/request \
     --header "Authorization: Bearer $PAWA_AI_API_KEY" \  
     --header 'Content-Type: application/json' \
     --data '{
      "model": "pawa-v1-blaze-20250318",
                 "messages": [
                  {
                     "role": "user",
                     "content": [
                           {
                              "type": "text",
                              "text": "What was the last years sales of the company?"
                           }
                     ]
                  }]
               "knowledgeBase": {
                  "kbReferenceId": "kb-930d251e-8a8b-4ba9-bae1-5fceb47bd654",
                  "isMust": "True"
               }}'
```

### Example Response demonstrating RAG based chat

```bash theme={null}
{
  "success": true,
  "message": "Chat request processed successfully",
  "data": {
    "request": [
      {
        "finish_reason": "stop",
        "message": {
          "role": "assistant",
          "content": "At Pawa AI, the last year sales was about 400K$ ARR, do you have any question i can help with?"
        },
        "matched_stop": 128001
      }
    ],
    "created": "2025-09-09",
    "model": "pawa-v1-ember-20240924",
    "object": "chat.request"
  }
}
```

> So, with this capability you don’t have to worry about building complex retrieval pipelines or managing embeddings yourself. Pawa AI handles the heavy lifting, letting you focus on integrating your data and delivering accurate, context-aware responses to your users.