Proposal for Enhancing PersistencyStorageProvider Interface Flexibility

[samDobsonDev]

The current design of the PersistencyStorageProvider interface requires each request to instantiate its own storage provider object. This approach can lead to scalability challenges, particularly in high-concurrency environments. This is because the interface does not currently support filtering based on user-specific or request-specific metrics, necessitating multiple instances for different filters that are passed in as constructor parameters. The PersistencyStorageProvider class is essentially a repository, so developers should have the option to use it as a singleton.

Proposed Enhancement:

Introduce a more flexible interface that allows developers to define their own filtering criteria. This can be achieved by allowing the interface methods to accept optional parameters for filtering, without prescribing a specific data structure or implementation.

Proposed Interface Concept:

package ai.koog.agents.snapshot.providers

import ai.koog.agents.snapshot.feature.AgentCheckpointData

public interface PersistencyStorageProvider<F> {
    public suspend fun getCheckpoints(filter: F): List<AgentCheckpointData>
    public suspend fun saveCheckpoint(agentCheckpointData: AgentCheckpointData, filter: F)
    public suspend fun getLatestCheckpoint(filter: F): AgentCheckpointData?
}

This would allow for classes to implement this interface like this:

data class CheckpointFilter(val userId: String, val time: Long)

class ExamplePersistencyStorageProvider : PersistencyStorageProvider<CheckpointFilter> {

    private val storage: MutableMap<String, MutableList<AgentCheckpointData>> = mutableMapOf()

    override suspend fun getCheckpoints(filter: CheckpointFilter): List<AgentCheckpointData> {
        return storage[filter.userId]?.filter { checkpoint -> checkpoint.createdAt <= filter.time } ?: emptyList()
    }

    override suspend fun saveCheckpoint(agentCheckpointData: AgentCheckpointData, filter: CheckpointFilter) {
        val checkpoints = storage.computeIfAbsent(filter.userId) { mutableListOf() }
        checkpoints.add(agentCheckpointData)
    }

    override suspend fun getLatestCheckpoint(filter: CheckpointFilter): AgentCheckpointData? {
        return storage[filter.userId]?.maxByOrNull { checkpoint -> checkpoint.createdAt }
    }
}

Benefits:

• Scalability: Supports singleton implementation, reducing memory usage.
• Flexibility: Developers can define their own filtering criteria, making the interface adaptable to various use cases.
• Generic Design: The use of a generic filter type allows for diverse filtering needs, enabling developers to tailor the implementation to their specific requirements.

Discussion Points:

• How to ensure backwards compatibility with existing implementations.
• Potential performance impacts of introducing flexible filtering logic.

[aozherelyeva]

Hi @samDobsonDev, thank you for the proposal!
@Rizzen, would you please take a look at the idea? 🙂 Thanks!

[hydarsalis406-max]

Nice