Crate mnemos 

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

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

┌─────────────────────────────────────────────────────────────┐
│                    mnemos                        │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────────────┐ │
│  │   CLI   │  │  gRPC   │  │   MCP   │  │  Library API    │ │
│  │         │  │ Server  │  │ Server  │  │                 │ │
│  └────┬────┘  └────┬────┘  └────┬────┘  └────────┬────────┘ │
│       │            │            │                │          │
│       └────────────┴────────────┴────────────────┘          │
│                           │                                  │
│  ┌────────────────────────┴───────────────────────────────┐ │
│  │                   KnowledgeBase                        │ │
│  │  ┌─────────────┐  ┌───────────────┐  ┌──────────────┐ │ │
│  │  │  Embedding  │  │   Learning    │  │   Storage    │ │ │
│  │  │   Engine    │  │    Engine     │  │   Backend    │ │ │
│  │  │  (Hash/ML)  │  │  (GNN-style)  │  │  (Bincode)   │ │ │
│  │  └─────────────┘  └───────────────┘  └──────────────┘ │ │
│  └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘

Re-exports

pub use crate::agentic::AgenticDB;

pub use crate::agentic::AgenticStats;

pub use crate::agentic::CausalEdge;

pub use crate::agentic::CausalMemory;

pub use crate::agentic::CausalNode;

pub use crate::agentic::Critique;

pub use crate::agentic::CritiqueType;

pub use crate::agentic::DriftDetector;

pub use crate::agentic::Experience;

pub use crate::agentic::ExperienceWindow;

pub use crate::agentic::FewShotLearner;

pub use crate::agentic::Hyperedge;

pub use crate::agentic::LearningSession;

pub use crate::agentic::LearningStrategy;

pub use crate::agentic::MetaLearner;

pub use crate::agentic::OnlineLearner;

pub use crate::agentic::ParameterSnapshot;

pub use crate::agentic::ReflexionEpisode;

pub use crate::agentic::ReflexionMemory;

pub use crate::agentic::Reward;

pub use crate::agentic::SessionTurn;

pub use crate::agentic::Skill;

pub use crate::agentic::SkillLibrary;

pub use crate::agentic::SkillPattern;

pub use crate::agentic::TaskFeatures;

pub use crate::agentic::TemporalMemory;

pub use crate::agentic::TemporalOccurrence;

pub use crate::agentic::TemporalPeriod;

pub use crate::agentic::TimeCrystal;

pub use crate::core::KnowledgeBase;

pub use crate::core::KnowledgeBaseConfig;

pub use crate::core::KnowledgeEntry;

pub use crate::core::SearchOptions;

pub use crate::core::SearchResult;

pub use crate::embedding::EmbeddingEngine;

pub use crate::error::Error;

pub use crate::error::Result;

pub use crate::learning::LearningEngine;

pub use crate::provenance::MNEMOS_PROVENANCE;

pub use crate::provenance::Mnemos;

pub use crate::storage::StorageBackend;

pub use crate::suggestor::KnowledgeHitPayload;

pub use crate::suggestor::KnowledgeRetrievalSuggestor;

pub use crate::suggestor::KnowledgeStoreSuggestor;

Modules

agentic

AgenticDB: Suggestor Memory System

core

Core types and knowledge base implementation.

embedding

Embedding generation for text vectorization.

error

Error types for the knowledge base.

grpc

gRPC service implementation.

ingest

Document ingestion module for extracting content from various file formats.

learning

Self-learning engine using GNN-inspired approaches.

provenance

Mnemos’s ProvenanceSource marker.

storage

Storage backend for persistence.

suggestor

Knowledge Suggestors — make the knowledge base participate in convergence.