llm4s-docs
API
Generated with
llm4s-docs/org.llm4s/org.llm4s.agent/org.llm4s.agent.memory/InMemoryStore

InMemoryStore

org.llm4s.agent.memory.InMemoryStore
See theInMemoryStore companion object
final case class InMemoryStore extends TransactionalMemoryStore

In-memory implementation of MemoryStore.

This implementation stores all memories in memory, making it suitable for testing, short-lived agents, and scenarios where persistence isn't required.

Features:

  • Fast lookups using indexed data structures
  • Whole-word keyword search, case-insensitive (semantic search requires embeddings)
  • Thread-safe for concurrent access
  • No external dependencies

Limitations:

  • Data is lost when the application terminates
  • Memory usage grows with stored memories
  • Keyword search is less sophisticated than vector search

Value parameters

config

Configuration options

memories

All stored memories indexed by ID

Attributes

Companion
object
Graph
Supertypes
trait Serializable
trait Product
trait Equals
trait MemoryStore
class Object
trait Matchable
class Any
Show all

Members list

Value members

Concrete methods

def all: Seq[Memory]

Get all memories (for debugging/testing).

Get all memories (for debugging/testing).

Attributes

override def appliedWrite(key: AppliedWriteKey, token: Long): Result[(TransactionalMemoryStore, Option[AppliedWrite])]

The outcome recorded for key, if it was applied; fenced like every operation.

The outcome recorded for key, if it was applied; fenced like every operation.

Attributes

Definition Classes
override def appliedWriteCount: Result[Int]

How many applied keys the store holds.

How many applied keys the store holds.

Attributes

Definition Classes
override def applyAtomically(key: AppliedWriteKey, token: Long, add: Seq[Memory], remove: Seq[MemoryId], bounds: MemoryBounds): Result[(TransactionalMemoryStore, AppliedWrite)]

Applies the write to this value and returns the new one: the transaction is the value, so a caller that shares the store between threads serialises its updates (as llm4s-agent-memory's tenant cell does).

Applies the write to this value and returns the new one: the transaction is the value, so a caller that shares the store between threads serialises its updates (as llm4s-agent-memory's tenant cell does).

Attributes

Definition Classes
override def clear(): Result[MemoryStore]

Removes every memory; applied writes and fencing tokens are kept, as TransactionalMemoryStore requires.

Removes every memory; applied writes and fencing tokens are kept, as TransactionalMemoryStore requires.

Attributes

Definition Classes
override def count(filter: MemoryFilter): Result[Long]

Count memories matching a filter.

Count memories matching a filter.

Value parameters

filter

Criteria for counting memories

Attributes

Returns

Count or error

Definition Classes
override def delete(id: MemoryId): Result[MemoryStore]

Delete a memory by its ID.

Delete a memory by its ID.

Value parameters

id

The memory identifier

Attributes

Returns

Updated store or error

Definition Classes
override def deleteMatching(filter: MemoryFilter): Result[MemoryStore]

Delete all memories matching a filter.

Delete all memories matching a filter.

Value parameters

filter

Criteria for selecting memories to delete

Attributes

Returns

Updated store or error

Definition Classes
override def forgetApplied(key: AppliedWriteKey, token: Long): Result[TransactionalMemoryStore]

Removes key's record; fenced like every operation. A key that is not there is Right.

Removes key's record; fenced like every operation. A key that is not there is Right.

Attributes

Definition Classes
override def get(id: MemoryId): Result[Option[Memory]]

Retrieve a memory by its ID.

Retrieve a memory by its ID.

Value parameters

id

The memory identifier

Attributes

Returns

The memory if found, or error

Definition Classes
override def recall(filter: MemoryFilter, limit: Int): Result[Seq[Memory]]

Recall memories matching a filter.

Recall memories matching a filter.

This is the primary retrieval method for most use cases. Returns memories sorted by relevance (most relevant first).

Value parameters

filter

Criteria for filtering memories

limit

Maximum number of memories to return

Attributes

Returns

Matching memories sorted by relevance (most relevant first), or error

Definition Classes
override def recent(limit: Int, filter: MemoryFilter): Result[Seq[Memory]]

Get the most recent memories.

Get the most recent memories.

Value parameters

filter

Additional filter criteria

limit

Maximum number of memories

Attributes

Returns

Most recent memories

Definition Classes
override def search(query: String, topK: Int, filter: MemoryFilter): Result[Seq[ScoredMemory]]

Semantic search for memories similar to a query.

Semantic search for memories similar to a query.

This method uses embeddings for semantic similarity search. Falls back to keyword search if embeddings are not available.

Value parameters

filter

Additional filter criteria

query

The search query

topK

Number of results to return

Attributes

Returns

A list of ScoredMemory objects, sorted by relevance score (highest first), or error

Definition Classes
def search(query: String, queryEmbedding: Array[Float], topK: Int, filter: MemoryFilter): Result[Seq[ScoredMemory]]

Semantic search for memories similar to an embedded query vector.

Semantic search for memories similar to an embedded query vector.

Computes cosine similarity between the query embedding and the stored memory embeddings, returning the top-K results.

Attributes

def size: Int

Get memory count.

Get memory count.

Attributes

override def store(memory: Memory): Result[MemoryStore]

Store a new memory.

Store a new memory.

Value parameters

memory

The memory to store

Attributes

Returns

Updated store or error

Definition Classes
override def update(id: MemoryId, updateFn: Memory => Memory): Result[MemoryStore]

Update a memory.

Update a memory.

Value parameters

id

The memory identifier

update

Function to transform the memory

Attributes

Returns

Updated store or error

Definition Classes

Inherited methods

def exists(id: MemoryId): Result[Boolean]

Check if a memory exists.

Check if a memory exists.

Value parameters

id

The memory identifier

Attributes

Returns

True if memory exists

Inherited from:
MemoryStore
def getConversation(conversationId: String, limit: Int): Result[Seq[Memory]]

Get conversation history.

Get conversation history.

Value parameters

conversationId

The conversation identifier

limit

Maximum messages to return

Attributes

Returns

Conversation memories in chronological order

Inherited from:
MemoryStore
def getEntityMemories(entityId: EntityId): Result[Seq[Memory]]

Get all memories for a specific entity.

Get all memories for a specific entity.

Value parameters

entityId

The entity identifier

Attributes

Returns

All memories related to this entity

Inherited from:
MemoryStore
def important(threshold: Double, limit: Int): Result[Seq[Memory]]

Get high-importance memories.

Get high-importance memories.

Value parameters

limit

Maximum number of memories

threshold

Minimum importance score (0.0 to 1.0)

Attributes

Returns

Important memories

Inherited from:
MemoryStore
def productElementNames: Iterator[String]

Attributes

Inherited from:
Product
def productIterator: Iterator[Any]

Attributes

Inherited from:
Product
def replace(add: Seq[Memory], remove: Seq[MemoryId]): Result[MemoryStore]

Store add, then delete remove: one replacement, such as a consolidation's summary for the memories it summarises. A memory of remove that is not there is skipped.

Store add, then delete remove: one replacement, such as a consolidation's summary for the memories it summarises. A memory of remove that is not there is skipped.

This default stores, then deletes one by one, so it is atomic for a store whose writes return a new store and leave the original untouched (as InMemoryStore does). SQLiteMemoryStore and the Postgres store override it as one transaction; any other store that writes in place should too.

Attributes

Returns

the store after the replacement, or an error

Inherited from:
MemoryStore
def storeAll(memories: Seq[Memory]): Result[MemoryStore]

Store multiple memories in a batch, all or nothing: on Left, none of memories has been stored (a memory that was already there is left as it was). A memory whose id appears twice is stored as its last occurrence.

Store multiple memories in a batch, all or nothing: on Left, none of memories has been stored (a memory that was already there is left as it was). A memory whose id appears twice is stored as its last occurrence.

This default stores into an immutable copy, so it is atomic for a store whose store returns a new store and leaves the original untouched (as InMemoryStore does). A store that writes in place must override it; the SQLite, vector and Postgres stores write the batch in one transaction.

Value parameters

memories

The memories to store

Attributes

Returns

A new MemoryStore containing the added memories, or an error describing why the operation failed.

Inherited from:
MemoryStore
Generated with