> For the complete documentation index, see [llms.txt](https://valeriis-organization.gitbook.io/repopilot-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://valeriis-organization.gitbook.io/repopilot-docs/repo_copilot/rag/rag.md).

# ClassDef RAGApp

**RAGApp**: The function of RAGApp is to provide a Retrieval-Augmented Generation (RAG) application interface for querying and interacting with a language model based on specific repository descriptions.

**attributes**: The attributes of this Class. · model\_name: The name of the language model to be used. · repo\_description: A description of the repository, which is used to tailor the model's responses.

**Code Description**: The RAGApp class is designed to facilitate interactions with a language model in the context of a specific repository. Upon initialization, it configures an instance of the App class with settings for the language model (LLM) and an embedder. The LLM is configured to use the OpenAI provider with specific parameters such as the number of documents, model name, temperature, max tokens, top\_p, and stream settings. The prompt is customized to focus on answering questions related to the repository description, ensuring that the model's responses are contextually relevant.

The embedder is set to use the Hugging Face provider with a specific model for embedding tasks. Additionally, the chunker is configured with a chunk size of 5000, which is likely used for processing large documents or data in manageable segments.

The class provides methods for adding data (add), querying the model (query), and resetting the application state (reset). These methods directly interact with the App instance, delegating the actual operations to it.

In the context of the project, RAGApp is used to provide a specialized interface for querying information related to a repository. Although the specific usage in the project is not detailed in the provided caller information, it can be inferred that RAGApp is intended to be used in scenarios where detailed and context-aware responses from a language model are required, particularly in the context of repository-related queries.

**Note**:

* Ensure that the model\_name provided is a valid model supported by the OpenAI provider.
* The repo\_description should be concise and relevant to the context in which the model will be used to avoid misleading or irrelevant responses.
* The chunk size for the chunker should be adjusted based on the nature of the data being processed to ensure efficient handling.

**Output Example**:

```python
# Example usage of RAGApp
rag_app = RAGApp(model_name="gpt-3.5-turbo", repo_description="A Python library for machine learning")
rag_app.add("https://example.com/documentation", data_type='web_page')
response = rag_app.query("How do I train a model using this library?")
print(response)
```

Possible output:

```
Answer: To train a model using this library, you would typically follow these steps:
1. Import the necessary modules.
2. Load your dataset.
3. Preprocess the data.
4. Define your model architecture.
5. Compile the model.
6. Train the model using the fit method.
7. Evaluate the model.
```

## FunctionDef **init**(self, model\_name, repo\_description)

**init**: The function of **init** is to initialize the RAGApp instance with specific configurations for the language model, embedder, and chunker.

**parameters**: The parameters of this Function. · model\_name: A string specifying the name of the language model to be used. · repo\_description: A string describing the repository, which is used to customize the prompt for the language model.

**Code Description**: The description of this Function. The `__init__` method initializes an instance of the `RAGApp` class by setting up the application with a configuration dictionary. This configuration includes settings for the language model (LLM), embedder, and chunker.

1. **Language Model (LLM) Configuration**:
   * **provider**: Set to "openai", indicating that the OpenAI API will be used.
   * **config**: A dictionary containing detailed configurations for the language model:
     * **number\_documents**: Set to 5, specifying the number of documents to be processed.
     * **model**: Set to the value of `model_name`, which is passed as a parameter to the `__init__` method.
     * **temperature**: Set to 0.0, indicating a deterministic output from the model.
     * **max\_tokens**: Set to 2048, limiting the maximum number of tokens in the output.
     * **top\_p**: Set to 1, indicating that nucleus sampling is not used.
     * **stream**: Set to False, indicating that the response will not be streamed.
     * **prompt**: A formatted string that includes the `repo_description` and provides instructions for the AI assistant. This prompt guides the assistant to answer questions related to the repository, use only provided information, and handle unknown answers or example requests appropriately.
2. **Embedder Configuration**:
   * **provider**: Set to "huggingface", indicating that the Hugging Face model will be used for embedding.
   * **config**: A dictionary containing the model configuration:
     * **model**: Set to "WhereIsAI/UAE-Large-V1", specifying the embedding model to be used.
3. **Chunker Configuration**:
   * **chunk\_size**: Set to 5000, specifying the size of the chunks for the chunker.

**Note**: Points to note about the use of the code

* Ensure that the `model_name` and `repo_description` parameters are correctly provided to match the intended use case.
* The prompt configuration is crucial as it defines the behavior of the AI assistant, especially in handling unknown information and providing examples.

***

## FunctionDef add(self, data, data\_type)

**add**: The function of add is to add data to the RAGApp.

**parameters**: The parameters of this Function. · data: The data to be added to the RAGApp. This can be any type of data that the RAGApp supports. · data\_type: The type of data being added, with a default value of 'web\_page'. This parameter specifies the type of data being added to help the RAGApp process it correctly.

**Code Description**: The `add` function is a method of the `RAGApp` class. It takes two parameters: `data` and `data_type`. The `data` parameter is the actual data that needs to be added to the RAGApp, and `data_type` is an optional parameter that specifies the type of data being added, defaulting to 'web\_page' if not provided.

Inside the function, the `self.app.add` method is called with the same parameters. This indicates that the `add` method of the `RAGApp` class is a wrapper for the `add` method of another object, presumably an instance of a class that handles the actual addition of data. This design allows for abstraction and separation of concerns, where the `RAGApp` class can focus on higher-level operations, delegating the specific task of adding data to another class.

The function is called in the `fedot_example.py` script, although the specific context and usage details are not provided in the given information. This suggests that the `add` function is part of a larger system where data from various sources (like web pages) are integrated into the RAGApp for further processing or analysis.

**Note**: When using the `add` function, ensure that the `data` parameter is correctly formatted and that the `data_type` parameter accurately reflects the type of data being added. This is crucial for the RAGApp to process the data correctly. Additionally, since the function delegates the actual addition of data to another object, it's important to ensure that this underlying object is properly configured and capable of handling the data being added.

***

## FunctionDef query(self, question, citations)

**query**: The function of query is to send a question to the RAGApp and retrieve a response.

**parameters**: The parameters of this Function. · question: A string representing the question to be asked. · citations: A boolean indicating whether to include citations in the response. Default is False.

**Code Description**: The `query` function is a method of the `RAGApp` class. It takes two parameters: `question` and `citations`. The `question` parameter is mandatory and should be a string that represents the question the user wants to ask. The `citations` parameter is optional and defaults to `False`. If set to `True`, it indicates that the response should include citations.

The function internally calls the `query` method of the `app` attribute of the `RAGApp` instance. This `app` attribute is presumably an instance of another class that is responsible for handling the actual querying logic. The `self.app.query(question, citations=citations)` call passes the `question` and `citations` parameters to this underlying querying mechanism.

**Note**: Ensure that the `app` attribute of the `RAGApp` instance is properly initialized with an object that has a `query` method capable of handling the `question` and `citations` parameters.

**Output Example**: The return value of the `query` function will be the response from the `app`'s `query` method. For example, if the `question` is "What is the capital of France?" and `citations` is `False`, the output might be:

```
"The capital of France is Paris."
```

If `citations` is `True`, the output might include additional information such as:

```
"The capital of France is Paris. [Source: Wikipedia]"
```

***

## FunctionDef reset(self)

**reset**: The function of reset is to reset the application state.

**parameters**: The parameters of this Function. · None

**Code Description**: The `reset` function is a method defined within a class, which calls another method named `reset` on the `app` attribute of the instance. Specifically, `self.app.reset()` invokes the `reset` method of the `app` object associated with the current instance of the class. This action is typically intended to reset the state of the application to its initial or default settings.

**Note**: Ensure that the `app` attribute of the instance has a `reset` method implemented, as calling `self.app.reset()` without this method will result in an `AttributeError`.

***