Struct SurrealMemory 

pub struct SurrealMemory { /* private fields */ }

Implementations

impl SurrealMemory

pub async fn graph_upsert_node( &self, kind: &str, text: &str, confidence: f32, status: &str, ) -> Result<String>

pub async fn graph_link( &self, from_id: &str, to_id: &str, rel: &str, ) -> Result<()>

pub async fn graph_neighbors( &self, node_id: &str, limit: usize, ) -> Result<Vec<GraphNode>>

pub async fn graph_match_text( &self, query: &str, limit: usize, ) -> Result<Vec<GraphNode>>

pub async fn graph_dream_from_loops( &self, open_loops: &[String], ) -> Result<usize>

Offline-style dream stub: link open-loop text to a low-confidence idea node.

pub fn format_graph_context(&self, nodes: &[GraphNode]) -> Option<String>

impl SurrealMemory

pub async fn db(&self) -> Result<Surreal<Db>>

pub async fn new<P: AsRef<Path>>(path: P) -> Result<Self>

Trait Implementations

impl Clone for SurrealMemory

fn clone(&self) -> SurrealMemory

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl MemoryBackend for SurrealMemory

fn as_any(&self) -> &dyn Any

For downcasting to concrete types

fn store<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, namespace: &'life1 str, key: &'life2 str, value: &'life3 str, metadata: Option<Value>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Store a key-value memory

fn recall<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 str, key: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<MemoryEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Recall a specific memory by key

fn search<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 str, query: &'life2 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Search memories by query (semantic or keyword)

fn forget<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 str, key: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a memory

fn list<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all memories in a namespace

fn store_conversation<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, chat_id: &'life1 str, sender_id: &'life2 str, role: &'life3 str, content: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Store a conversation message

fn store_conversation_batch<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, entries: &'life1 [(&'life2 str, &'life3 str, &'life4 str, &'life5 str)], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Store multiple conversation messages in one batch.

fn get_conversation_history<'life0, 'life1, 'async_trait>( &'life0 self, chat_id: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, String)>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get recent conversation history (returns role, content pairs)

fn clear_conversation<'life0, 'life1, 'async_trait>( &'life0 self, chat_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete every stored message for one chat.

fn search_conversations<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, query: &'life1 str, limit: usize, chat_id: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ConversationSearchHit>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_sticker_cache<'life0, 'life1, 'async_trait>( &'life0 self, sticker_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get cached sticker description by ID

fn store_sticker_cache<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, sticker_id: &'life1 str, file_id: &'life2 str, description: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Store sticker cache (sticker_id → description)

fn store_embedding<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, namespace: &'life1 str, key: &'life2 str, vector: &'life3 [f32], text: &'life4 str, model: &'life5 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Store a vector embedding for a memory key

fn search_embeddings<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 str, query_vector: &'life2 [f32], limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<EmbeddingEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Search embeddings by cosine similarity (returns nearest matches)

fn store_file_index<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, path: &'life1 str, hash: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Record that a file has been indexed

fn get_file_index<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<FileIndex>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get file index entry (to check if re-indexing is needed)

fn store_chunk<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, file_path: &'life1 str, start_line: u32, end_line: u32, content: &'life2 str, embedding: Option<&'life3 [f32]>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Store a code chunk with optional embedding

fn get_chunks_for_file<'life0, 'life1, 'async_trait>( &'life0 self, file_path: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Chunk>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Search chunks by file path

fn delete_chunks_for_file<'life0, 'life1, 'async_trait>( &'life0 self, file_path: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete all chunks for a file (before re-indexing)