post-cortex-memory

Conversation memory orchestrator for post-cortex.

Ties post-cortex-core, post-cortex-storage, post-cortex-embeddings, and post-cortex-proto into a single lock-free memory hierarchy with async pipelines and a canonical service trait.

Writes go through MemoryServiceImpl::update_context: the request is redacted (see post_cortex_core::redact), validated, and returned only after the storage write is acknowledged (durable in the response). Embedding, entity-graph merge and summary refresh then run on the bounded background pipeline. Session persists are coalesced and ordered per session, so the newest snapshot is always written last.

Install

[dependencies]
post-cortex-memory = "0.4"

What's inside

Example

use post_cortex_core::services::PostCortexService; // from post-cortex-core
use post_cortex_memory::{ConversationMemorySystem, MemoryServiceImpl, SystemConfig};
use std::sync::Arc;
use std::time::Duration;

async fn run() -> Result<(), Box<dyn std::error::Error>> {
    let config = SystemConfig {
        data_directory: "./pcx-data".into(),
        ..Default::default()
    };
    let system = Arc::new(ConversationMemorySystem::new(config).await?);
    let session_id = system
        .create_session(Some("demo".into()), None)
        .await?;
    println!("created session {session_id}");

    // Every transport writes through the canonical service.
    let service = MemoryServiceImpl::new(system.clone());
    println!("health: {}", service.health().await?.status);

    // Listing reads session metadata only; sessions are not loaded.
    for summary in system.list_session_summaries().await? {
        println!("{} {:?}", summary.id, summary.name);
    }

    // On shutdown, write every queued session persist.
    system.flush_all(Duration::from_secs(10)).await;
    Ok(())
}

Features

License

MIT — see LICENSE.