post-cortex 0.4.0

Intelligent conversation memory system for AI assistants — persistent knowledge storage, semantic search, knowledge graph, MCP + gRPC transports. Facade crate re-exporting the post-cortex workspace stack.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

#![allow(missing_docs)]
use chrono::Utc;
use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
use std::hint::black_box;
use std::sync::Arc;
use uuid::Uuid;

use post_cortex_memory::content_vectorizer::{ContentType, SemanticSearchResult};
use post_cortex_memory::query_cache::{CacheScope, QueryCache, QueryCacheConfig};

fn create_test_results() -> Arc<[SemanticSearchResult]> {
    Arc::from(vec![
        SemanticSearchResult {
            content_id: Uuid::new_v4().to_string(),
            session_id: Uuid::new_v4(),
            content_type: ContentType::UpdateContent,
            text_content: "Test result 1".to_string(),
            similarity_score: 0.9,
            importance_score: 0.5,
            timestamp: Utc::now(),
            combined_score: 0.78,
        },
        SemanticSearchResult {
            content_id: Uuid::new_v4().to_string(),
            session_id: Uuid::new_v4(),
            content_type: ContentType::UpdateContent,
            text_content: "Test result 2".to_string(),
            similarity_score: 0.8,
            importance_score: 0.5,
            timestamp: Utc::now(),
            combined_score: 0.71,
        },
    ])
}

fn bench_cache_search(c: &mut Criterion) {
    let mut group = c.benchmark_group("query_cache_search");

    for &load in &[16usize, 64, 256] {
        group.bench_with_input(
            BenchmarkId::new("search_hit_rate", load),
            &load,
            |b, &load| {
                b.iter_batched(
                    || {
                        let cache = QueryCache::new(QueryCacheConfig::default());
                        let results = create_test_results();
                        for i in 0..load {
                            let query_text = format!("query {}", i);
                            cache.insert(
                                query_text,
                                Arc::clone(&results),
                                i as u64,
                                CacheScope::Global,
                            );
                        }
                        cache
                    },
                    |cache| {
                        for j in 0..load {
                            let query_text = format!("query {}", j % load);
                            let params_hash = (j % load) as u64;
                            let hit = cache.get(params_hash, &query_text);
                            black_box(hit);
                        }
                    },
                    criterion::BatchSize::SmallInput,
                );
            },
        );
    }

    group.finish();
}

fn bench_cache_insert(c: &mut Criterion) {
    c.bench_function("query_cache_insert_100", |b| {
        b.iter_batched(
            || {
                (
                    QueryCache::new(QueryCacheConfig::default()),
                    create_test_results(),
                )
            },
            |(cache, results)| {
                for i in 0..100usize {
                    let query_text = format!("query {}", i);
                    cache.insert(
                        query_text,
                        Arc::clone(&results),
                        i as u64,
                        CacheScope::Global,
                    );
                }
            },
            criterion::BatchSize::SmallInput,
        );
    });
}

criterion_group!(benches, bench_cache_search, bench_cache_insert);
criterion_main!(benches);