# Advanced Usage

## Create your own Custom Memory Component

Each stack component has three Base Interfaces.

Base Interfaces for the Memory component

```py
class BaseMemoryConfigModel(BaseModel):
    """
    Data Model for the configs
    """
    pass


class BaseMemoryConfig(StackComponentConfig):
    data_model = BaseMemoryConfigModel


class BaseMemory(StackComponent):

    def get_user_text(self) -> str:
        """
        This method returns the user query
        """
        raise NotImplementedError()

    def get_model_text(self) -> str:
        """
        This method returns the model response
        """
        raise NotImplementedError()

    def get_text(self) -> dict:
        """
        This method returns both user query and model response
        """
        raise NotImplementedError()

    def add_text(self, user_text:str, model_text:str) -> None:
        """
        This method stores both user query and model response
        """
        raise NotImplementedError()

    def get_chat_history(self) -> str:
        """
        This method returns the chat conversation history
        """
        raise NotImplementedError()
```

**1. Creating a Custom Memory Component**: Create a new class that extends the BaseMemory class. Here's an example of how to create a custom memory.

```py
class CustomMemory(BaseMemory):
    def get_user_text(self) -> str:
        # Implement logic to retrieve user's query
        pass

    def get_model_text(self) -> str:
        # Implement logic to retrieve model's response
        pass

    def get_text(self) -> dict:
        # Implement logic to return both user's query and model's response
        pass

    def add_text(self, user_text: str, model_text: str) -> None:
        # Implement logic to store user's query and model's response
        pass

    def get_chat_history(self) -> str:
        # Implement logic to retrieve chat conversation history
        pass
```

**2. Customizing Memory Logic**: In the CustomMemory class, users need to implement the methods defined in the BaseMemory interface. These methods include:

* get\_user\_text(): Implement this method to retrieve the user's query.
* get\_model\_text(): Implement this method to retrieve the model's response.
* get\_text(): Implement this method to return both the user's query and the model's response, typically as a dictionary or a structured data format.
* add\_text(user\_text, model\_text): Implement this method to store both the user's query and the model's response in your custom memory component.
* get\_chat\_history(): Implement this method to retrieve the complete chat conversation history.

**3. Custom Configuration data model**: Users can also provide the data model for the configurations which will be specific to their custom memory class. create a new custom memory config model class that extends the base memory config model class and specify the configuration fields and their types.

```py
class CustomMemoryConfigModel(BaseMemoryConfigModel):
    custom_field: str = "default_value"
```

**4. Custom Configuration**: If you are creating a custom memory config model which contains specific configurations for the custom memory component, then you also need a custom configuration class that extends BaseMemoryConfig to define their own configuration class specific to their custom memory component. For example:

```py
class CustomMemoryConfig(BaseMemoryConfig):
    data_model = CustomMemoryConfigModel
```

**5. Using Custom Configuration**: To use the custom configuration class, users can modify their custom memory class to specify the custom configuration class

```py
class CustomMemory(BaseMemory):
    config_class = CustomMemoryConfig
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://genaistack.aiplanet.com/components/memory/advance-usage.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.