converge-mnemos-knowledge 1.2.2

Self-learning knowledgebase with vector search, gRPC, and MCP interfaces. Implements Converge recall and storage suggestors.
Documentation 
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! # mnemos
//!
//! A self-learning knowledgebase built on ruvector that gets smarter the more you use it.
//!
//! ## Features
//!
//! - **Vector Storage**: High-performance HNSW-based vector indexing
//! - **Self-Learning**: Adaptive query understanding using GNN-inspired learning
//! - **Knowledge Graph**: Semantic relationships between knowledge entries
//! - **Hybrid Search**: Combine vector similarity with metadata filtering
//! - **gRPC Interface**: High-performance RPC for service integration
//! - **MCP Server**: Model Context Protocol for Claude Desktop
//! - **Suggestor Adapters**: Knowledge retrieval and persistence inside the
//!   convergence loop
//!
//! ## Quick Start
//!
//! ```rust,no_run
//! use mnemos::{KnowledgeBase, KnowledgeEntry};
//!
//! #[tokio::main]
//! async fn main() -> anyhow::Result<()> {
//!     let kb = KnowledgeBase::open("./knowledge.db").await?;
//!
//!     // Add knowledge
//!     kb.add_entry(KnowledgeEntry::new(
//!         "Rust Memory Safety",
//!         "Rust ensures memory safety through ownership and borrowing rules...",
//!     )).await?;
//!
//!     // Search with learning
//!     let results = kb.search_simple("memory management in rust", 5).await?;
//!
//!     Ok(())
//! }
//! ```
//!
//! ## Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────────┐
//! │                    mnemos                        │
//! ├─────────────────────────────────────────────────────────────┤
//! │  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────────────┐ │
//! │  │   CLI   │  │  gRPC   │  │   MCP   │  │  Library API    │ │
//! │  │         │  │ Server  │  │ Server  │  │                 │ │
//! │  └────┬────┘  └────┬────┘  └────┬────┘  └────────┬────────┘ │
//! │       │            │            │                │          │
//! │       └────────────┴────────────┴────────────────┘          │
//! │                           │                                  │
//! │  ┌────────────────────────┴───────────────────────────────┐ │
//! │  │                   KnowledgeBase                        │ │
//! │  │  ┌─────────────┐  ┌───────────────┐  ┌──────────────┐ │ │
//! │  │  │  Embedding  │  │   Learning    │  │   Storage    │ │ │
//! │  │  │   Engine    │  │    Engine     │  │   Backend    │ │ │
//! │  │  │  (Hash/ML)  │  │  (GNN-style)  │  │  (Bincode)   │ │ │
//! │  │  └─────────────┘  └───────────────┘  └──────────────┘ │ │
//! │  └────────────────────────────────────────────────────────┘ │
//! └─────────────────────────────────────────────────────────────┘
//! ```

#![forbid(unsafe_code)]
#![warn(missing_docs)]

pub mod agentic;
pub mod core;
pub mod embedding;
pub mod error;
pub mod ingest;
pub mod learning;
pub mod provenance;
pub mod storage;
pub mod suggestor;

#[cfg(feature = "grpc")]
pub mod grpc;

// Re-exports
pub use crate::agentic::{
    // Core agent memory
    AgenticDB,
    AgenticStats,
    CausalEdge,
    // Causal memory
    CausalMemory,
    CausalNode,
    Critique,
    CritiqueType,
    DriftDetector,
    Experience,
    ExperienceWindow,
    FewShotLearner,
    Hyperedge,
    // Learning sessions
    LearningSession,
    LearningStrategy,
    // Meta-learning
    MetaLearner,
    // Online/continual learning
    OnlineLearner,
    ParameterSnapshot,
    // Reflexion (self-critique)
    ReflexionEpisode,
    ReflexionMemory,
    Reward,
    SessionTurn,
    // Skills
    Skill,
    SkillLibrary,
    SkillPattern,
    TaskFeatures,
    TemporalMemory,
    TemporalOccurrence,
    TemporalPeriod,
    // Temporal patterns (time crystals)
    TimeCrystal,
};
pub use crate::core::{
    KnowledgeBase, KnowledgeBaseConfig, KnowledgeEntry, SearchOptions, SearchResult,
};
pub use crate::embedding::EmbeddingEngine;
pub use crate::error::{Error, Result};
pub use crate::learning::LearningEngine;
pub use crate::provenance::{MNEMOS_PROVENANCE, Mnemos};
pub use crate::storage::StorageBackend;
pub use crate::suggestor::{
    KnowledgeHitPayload, KnowledgeRetrievalSuggestor, KnowledgeStoreSuggestor,
};