llm-memory-graph 0.1.0

//! Async interface for the memory graph using Tokio runtime
//!
//! This module provides a fully async API for all graph operations, enabling
//! high-performance concurrent operations and non-blocking I/O.

use crate::error::{Error, Result};
use crate::observatory::{
    EventPublisher, MemoryGraphEvent, MemoryGraphMetrics, NoOpPublisher, ObservatoryConfig,
};
use crate::storage::{AsyncSledBackend, AsyncStorageBackend, StorageCache};
use crate::types::{
    AgentId, AgentNode, Config, ConversationSession, Edge, EdgeType, Node, NodeId, PromptMetadata,
    PromptNode, PromptTemplate, ResponseMetadata, ResponseNode, SessionId, TemplateId, TokenUsage,
    ToolInvocation,
};
use chrono::Utc;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Instant;
use tokio::sync::RwLock;

/// Type alias for batch conversation data: (SessionId, prompt_content), optional (response_content, TokenUsage)
type ConversationBatchItem = ((SessionId, String), Option<(String, TokenUsage)>);

/// Async interface for interacting with the memory graph
///
/// `AsyncMemoryGraph` provides a fully async, thread-safe API for managing conversation
/// sessions, prompts, responses, agents, templates, and their relationships in a graph structure.
///
/// All operations are non-blocking and can be executed concurrently without performance degradation.
///
/// # Examples
///
/// ```no_run
/// use llm_memory_graph::engine::AsyncMemoryGraph;
/// use llm_memory_graph::Config;
///
/// #[tokio::main]
/// async fn main() -> Result<(), Box<dyn std::error::Error>> {
///     let config = Config::new("./data/my_graph.db");
///     let graph = AsyncMemoryGraph::open(config).await?;
///
///     let session = graph.create_session().await?;
///     let prompt_id = graph.add_prompt(session.id, "What is Rust?".to_string(), None).await?;
///     Ok(())
/// }
/// ```
pub struct AsyncMemoryGraph {
    backend: Arc<dyn AsyncStorageBackend>,
    sessions: Arc<RwLock<HashMap<SessionId, ConversationSession>>>,
    observatory: Option<Arc<dyn EventPublisher>>,
    metrics: Option<Arc<MemoryGraphMetrics>>,
    cache: StorageCache,
}

impl AsyncMemoryGraph {
    /// Open or create an async memory graph with the given configuration
    ///
    /// This will create the database directory if it doesn't exist and initialize
    /// all necessary storage trees. Operations use Tokio's async runtime.
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - The database path is invalid or inaccessible
    /// - Storage initialization fails
    /// - Existing data is corrupted
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use llm_memory_graph::engine::AsyncMemoryGraph;
    /// use llm_memory_graph::Config;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let config = Config::new("./data/graph.db");
    ///     let graph = AsyncMemoryGraph::open(config).await?;
    ///     Ok(())
    /// }
    /// ```
    pub async fn open(config: Config) -> Result<Self> {
        let backend = AsyncSledBackend::open(&config.path).await?;

        // Convert cache size from MB to approximate entry count
        // Assume ~1KB per node, so 100MB = ~100,000 nodes
        let node_capacity = (config.cache_size_mb as u64) * 1000;
        let edge_capacity = node_capacity * 5; // Edges are smaller, cache more

        let cache = StorageCache::with_capacity(node_capacity, edge_capacity);

        Ok(Self {
            backend: Arc::new(backend),
            sessions: Arc::new(RwLock::new(HashMap::new())),
            observatory: None,
            metrics: None,
            cache,
        })
    }

    /// Open graph with Observatory integration
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use llm_memory_graph::engine::AsyncMemoryGraph;
    /// use llm_memory_graph::observatory::{ObservatoryConfig, InMemoryPublisher};
    /// use llm_memory_graph::Config;
    /// use std::sync::Arc;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let config = Config::default();
    ///     let publisher = Arc::new(InMemoryPublisher::new());
    ///     let obs_config = ObservatoryConfig::new().enabled();
    ///
    ///     let graph = AsyncMemoryGraph::with_observatory(
    ///         config,
    ///         Some(publisher),
    ///         obs_config
    ///     ).await?;
    ///     Ok(())
    /// }
    /// ```
    pub async fn with_observatory(
        config: Config,
        publisher: Option<Arc<dyn EventPublisher>>,
        obs_config: ObservatoryConfig,
    ) -> Result<Self> {
        let backend = AsyncSledBackend::open(&config.path).await?;

        // Convert cache size from MB to approximate entry count
        // Assume ~1KB per node, so 100MB = ~100,000 nodes
        let node_capacity = (config.cache_size_mb as u64) * 1000;
        let edge_capacity = node_capacity * 5; // Edges are smaller, cache more

        let cache = StorageCache::with_capacity(node_capacity, edge_capacity);

        let metrics = if obs_config.enable_metrics {
            Some(Arc::new(MemoryGraphMetrics::new()))
        } else {
            None
        };

        let observatory = if obs_config.enabled {
            publisher.or_else(|| Some(Arc::new(NoOpPublisher)))
        } else {
            None
        };

        Ok(Self {
            backend: Arc::new(backend),
            sessions: Arc::new(RwLock::new(HashMap::new())),
            observatory,
            metrics,
            cache,
        })
    }

    /// Get metrics snapshot
    pub fn get_metrics(&self) -> Option<crate::observatory::MetricsSnapshot> {
        self.metrics.as_ref().map(|m| m.snapshot())
    }

    /// Publish an event to Observatory (non-blocking)
    fn publish_event(&self, event: MemoryGraphEvent) {
        if let Some(obs) = &self.observatory {
            let obs = Arc::clone(obs);
            tokio::spawn(async move {
                if let Err(e) = obs.publish(event).await {
                    tracing::warn!("Failed to publish Observatory event: {}", e);
                }
            });
        }
    }

    // ===== Session Management =====

    /// Create a new conversation session asynchronously
    ///
    /// Sessions are used to group related prompts and responses together.
    /// Each session has a unique ID and can store custom metadata.
    ///
    /// # Errors
    ///
    /// Returns an error if the session cannot be persisted to storage.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::Config;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// let session = graph.create_session().await?;
    /// println!("Created session: {}", session.id);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn create_session(&self) -> Result<ConversationSession> {
        let start = Instant::now();

        let session = ConversationSession::new();
        let node = Node::Session(session.clone());
        self.backend.store_node(&node).await?;

        // Cache the session in both session cache and node cache
        self.sessions
            .write()
            .await
            .insert(session.id, session.clone());
        self.cache.insert_node(session.node_id, node).await;

        // Record metrics
        let latency_us = start.elapsed().as_micros() as u64;
        if let Some(metrics) = &self.metrics {
            metrics.record_node_created();
            metrics.record_write_latency_us(latency_us);
        }

        // Publish event
        self.publish_event(MemoryGraphEvent::NodeCreated {
            node_id: session.node_id,
            node_type: crate::types::NodeType::Session,
            session_id: Some(session.id),
            timestamp: Utc::now(),
            metadata: session.metadata.clone(),
        });

        Ok(session)
    }

    /// Create a session with custom metadata asynchronously
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::Config;
    /// # use std::collections::HashMap;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// let mut metadata = HashMap::new();
    /// metadata.insert("user_id".to_string(), "123".to_string());
    /// let session = graph.create_session_with_metadata(metadata).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn create_session_with_metadata(
        &self,
        metadata: HashMap<String, String>,
    ) -> Result<ConversationSession> {
        let session = ConversationSession::with_metadata(metadata);
        let node = Node::Session(session.clone());
        self.backend.store_node(&node).await?;

        // Cache the session in both session cache and node cache
        self.sessions
            .write()
            .await
            .insert(session.id, session.clone());
        self.cache.insert_node(session.node_id, node).await;

        Ok(session)
    }

    /// Get a session by ID asynchronously
    ///
    /// This will first check the in-memory cache, then fall back to storage.
    ///
    /// # Errors
    ///
    /// Returns an error if the session doesn't exist or storage retrieval fails.
    pub async fn get_session(&self, session_id: SessionId) -> Result<ConversationSession> {
        // Check cache first
        {
            let sessions = self.sessions.read().await;
            if let Some(session) = sessions.get(&session_id) {
                return Ok(session.clone());
            }
        }

        // Fall back to storage
        let session_nodes = self.backend.get_session_nodes(&session_id).await?;

        for node in session_nodes {
            if let Node::Session(session) = node {
                if session.id == session_id {
                    // Update cache
                    self.sessions
                        .write()
                        .await
                        .insert(session_id, session.clone());
                    return Ok(session);
                }
            }
        }

        Err(Error::SessionNotFound(session_id.to_string()))
    }

    // ===== Prompt Operations =====

    /// Add a prompt node to a session asynchronously
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::Config;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let session = graph.create_session().await?;
    /// let prompt_id = graph.add_prompt(
    ///     session.id,
    ///     "Explain async/await in Rust".to_string(),
    ///     None
    /// ).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn add_prompt(
        &self,
        session_id: SessionId,
        content: String,
        metadata: Option<PromptMetadata>,
    ) -> Result<NodeId> {
        let start = Instant::now();

        // Verify session exists
        self.get_session(session_id).await?;

        let prompt = PromptNode {
            id: NodeId::new(),
            session_id,
            content: content.clone(),
            metadata: metadata.clone().unwrap_or_default(),
            timestamp: chrono::Utc::now(),
            template_id: None,
            variables: HashMap::new(),
        };

        let prompt_id = prompt.id;
        let node = Node::Prompt(prompt.clone());
        self.backend.store_node(&node).await?;

        // Populate cache for immediate read performance
        self.cache.insert_node(prompt_id, node).await;

        // Create PartOf edge - get session node to get its NodeId
        let session_nodes = self.backend.get_session_nodes(&session_id).await?;
        if let Some(session_node) = session_nodes.iter().find(|n| matches!(n, Node::Session(_))) {
            let edge = Edge::new(prompt_id, session_node.id(), EdgeType::PartOf);
            self.backend.store_edge(&edge).await?;
            // Cache the edge
            self.cache.insert_edge(edge.id, edge).await;
        }

        // Record metrics
        let latency_us = start.elapsed().as_micros() as u64;
        if let Some(metrics) = &self.metrics {
            metrics.record_node_created();
            metrics.record_prompt_submitted();
            metrics.record_write_latency_us(latency_us);
        }

        // Publish event
        self.publish_event(MemoryGraphEvent::PromptSubmitted {
            prompt_id,
            session_id,
            content_length: content.len(),
            model: metadata.unwrap_or_default().model,
            timestamp: Utc::now(),
        });

        Ok(prompt_id)
    }

    /// Add multiple prompts concurrently (batch operation)
    ///
    /// This method processes all prompts in parallel for maximum throughput.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::Config;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let session = graph.create_session().await?;
    /// let prompts = vec![
    ///     (session.id, "First prompt".to_string()),
    ///     (session.id, "Second prompt".to_string()),
    /// ];
    /// let ids = graph.add_prompts_batch(prompts).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn add_prompts_batch(
        &self,
        prompts: Vec<(SessionId, String)>,
    ) -> Result<Vec<NodeId>> {
        let futures: Vec<_> = prompts
            .into_iter()
            .map(|(session_id, content)| self.add_prompt(session_id, content, None))
            .collect();

        futures::future::try_join_all(futures).await
    }

    // ===== Response Operations =====

    /// Add a response node linked to a prompt asynchronously
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::{Config, TokenUsage};
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let session = graph.create_session().await?;
    /// # let prompt_id = graph.add_prompt(session.id, "Hello".to_string(), None).await?;
    /// let usage = TokenUsage::new(10, 50);
    /// let response_id = graph.add_response(
    ///     prompt_id,
    ///     "Async operations are non-blocking!".to_string(),
    ///     usage,
    ///     None
    /// ).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn add_response(
        &self,
        prompt_id: NodeId,
        content: String,
        token_usage: TokenUsage,
        metadata: Option<ResponseMetadata>,
    ) -> Result<NodeId> {
        let start = Instant::now();

        let response = ResponseNode {
            id: NodeId::new(),
            prompt_id,
            timestamp: chrono::Utc::now(),
            content: content.clone(),
            usage: token_usage,
            metadata: metadata.unwrap_or_default(),
        };

        let response_id = response.id;
        let node = Node::Response(response.clone());
        self.backend.store_node(&node).await?;

        // Populate cache for immediate read performance
        self.cache.insert_node(response_id, node).await;

        // Create RespondsTo edge
        let edge = Edge::new(response_id, prompt_id, EdgeType::RespondsTo);
        self.backend.store_edge(&edge).await?;
        // Cache the edge
        self.cache.insert_edge(edge.id, edge).await;

        // Record metrics
        let latency_us = start.elapsed().as_micros() as u64;
        if let Some(metrics) = &self.metrics {
            metrics.record_node_created();
            metrics.record_response_generated();
            metrics.record_write_latency_us(latency_us);
        }

        // Publish event
        let response_latency_ms = latency_us / 1000;
        self.publish_event(MemoryGraphEvent::ResponseGenerated {
            response_id,
            prompt_id,
            content_length: content.len(),
            tokens_used: token_usage,
            latency_ms: response_latency_ms,
            timestamp: Utc::now(),
        });

        Ok(response_id)
    }

    // ===== Agent Operations =====

    /// Add an agent node asynchronously
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::{Config, AgentNode};
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// let agent = AgentNode::new(
    ///     "CodeReviewer".to_string(),
    ///     "code-review".to_string(),
    ///     vec!["rust".to_string(), "python".to_string()]
    /// );
    /// let agent_id = graph.add_agent(agent).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn add_agent(&self, agent: AgentNode) -> Result<AgentId> {
        let agent_id = agent.id;
        let node_id = agent.node_id;
        let node = Node::Agent(agent);
        self.backend.store_node(&node).await?;

        // Populate cache for immediate read performance
        self.cache.insert_node(node_id, node).await;

        Ok(agent_id)
    }

    /// Update an existing agent asynchronously
    ///
    /// This invalidates the cache entry for the agent to ensure consistency.
    pub async fn update_agent(&self, agent: AgentNode) -> Result<()> {
        let node_id = agent.node_id;
        self.backend.store_node(&Node::Agent(agent)).await?;

        // Invalidate cache to ensure consistency
        self.cache.invalidate_node(&node_id).await;

        Ok(())
    }

    /// Assign an agent to handle a prompt asynchronously
    ///
    /// Creates a HandledBy edge from the prompt to the agent.
    pub async fn assign_agent_to_prompt(
        &self,
        prompt_id: NodeId,
        agent_node_id: NodeId,
    ) -> Result<()> {
        let edge = Edge::new(prompt_id, agent_node_id, EdgeType::HandledBy);
        self.backend.store_edge(&edge).await
    }

    /// Transfer from one agent to another asynchronously
    ///
    /// Creates a TransfersTo edge representing agent handoff.
    pub async fn transfer_to_agent(
        &self,
        from_response: NodeId,
        to_agent_node_id: NodeId,
    ) -> Result<()> {
        let edge = Edge::new(from_response, to_agent_node_id, EdgeType::TransfersTo);
        self.backend.store_edge(&edge).await
    }

    // ===== Template Operations =====

    /// Create a new prompt template asynchronously
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::{Config, PromptTemplate, VariableSpec};
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// let template = PromptTemplate::new(
    ///     "Greeting".to_string(),
    ///     "Hello {{name}}!".to_string(),
    ///     vec![]
    /// );
    /// let template_id = graph.create_template(template).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn create_template(&self, template: PromptTemplate) -> Result<TemplateId> {
        let template_id = template.id;
        let template_node_id = template.node_id;
        let node = Node::Template(template);
        self.backend.store_node(&node).await?;

        // Populate cache for immediate read performance
        self.cache.insert_node(template_node_id, node).await;

        Ok(template_id)
    }

    /// Update an existing template asynchronously
    ///
    /// This invalidates the cache entry for the template to ensure consistency.
    pub async fn update_template(&self, template: PromptTemplate) -> Result<()> {
        let template_node_id = template.node_id;
        self.backend.store_node(&Node::Template(template)).await?;

        // Invalidate cache to ensure consistency
        self.cache.invalidate_node(&template_node_id).await;

        Ok(())
    }

    /// Get a template by its template ID asynchronously
    pub async fn get_template(&self, template_id: TemplateId) -> Result<PromptTemplate> {
        // Search through all nodes to find the template
        // This is a simplified implementation - in production, you'd want an index
        let all_sessions = self.backend.get_session_nodes(&SessionId::new()).await?;

        for node in all_sessions {
            if let Node::Template(template) = node {
                if template.id == template_id {
                    return Ok(template);
                }
            }
        }

        Err(Error::NodeNotFound(format!("Template {}", template_id)))
    }

    /// Get a template by its node ID asynchronously
    pub async fn get_template_by_node_id(&self, node_id: NodeId) -> Result<PromptTemplate> {
        if let Some(Node::Template(template)) = self.backend.get_node(&node_id).await? {
            return Ok(template);
        }

        Err(Error::NodeNotFound(node_id.to_string()))
    }

    /// Create template from parent (inheritance) asynchronously
    pub async fn create_template_from_parent(
        &self,
        template: PromptTemplate,
        parent_node_id: NodeId,
    ) -> Result<TemplateId> {
        let template_node_id = template.node_id;
        let template_id = template.id;

        // Store the new template
        self.backend.store_node(&Node::Template(template)).await?;

        // Create Inherits edge
        let edge = Edge::new(template_node_id, parent_node_id, EdgeType::Inherits);
        self.backend.store_edge(&edge).await?;

        Ok(template_id)
    }

    /// Link a prompt to the template it was instantiated from
    pub async fn link_prompt_to_template(
        &self,
        prompt_id: NodeId,
        template_node_id: NodeId,
    ) -> Result<()> {
        let edge = Edge::new(prompt_id, template_node_id, EdgeType::Instantiates);
        self.backend.store_edge(&edge).await
    }

    // ===== Tool Invocation Operations =====

    /// Add a tool invocation node asynchronously
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::{Config, ToolInvocation, NodeId};
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let response_id = NodeId::new();
    /// let tool = ToolInvocation::new(
    ///     response_id,
    ///     "calculator".to_string(),
    ///     serde_json::json!({"operation": "add", "a": 2, "b": 3})
    /// );
    /// let tool_id = graph.add_tool_invocation(tool).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn add_tool_invocation(&self, tool: ToolInvocation) -> Result<NodeId> {
        let tool_id = tool.id;
        let response_id = tool.response_id;

        // Store the tool invocation node
        let node = Node::ToolInvocation(tool);
        self.backend.store_node(&node).await?;

        // Populate cache for immediate read performance
        self.cache.insert_node(tool_id, node).await;

        // Create INVOKES edge from response to tool
        let edge = Edge::new(response_id, tool_id, EdgeType::Invokes);
        self.backend.store_edge(&edge).await?;
        // Cache the edge
        self.cache.insert_edge(edge.id, edge).await;

        Ok(tool_id)
    }

    /// Update tool invocation with results asynchronously
    ///
    /// This invalidates the cache entry for the tool to ensure consistency.
    pub async fn update_tool_invocation(&self, tool: ToolInvocation) -> Result<()> {
        let tool_id = tool.id;
        self.backend.store_node(&Node::ToolInvocation(tool)).await?;

        // Invalidate cache to ensure consistency
        self.cache.invalidate_node(&tool_id).await;

        Ok(())
    }

    // ===== Edge and Traversal Operations =====

    /// Get a node by ID asynchronously (cache-aware)
    ///
    /// This method first checks the cache for the node. If found in cache,
    /// it returns immediately (< 1ms latency). Otherwise, it loads from
    /// storage and populates the cache for future requests.
    ///
    /// # Performance
    ///
    /// - Cache hit: < 1ms latency
    /// - Cache miss: 2-10ms latency (loads from storage)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::{Config, NodeId};
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let node_id = NodeId::new();
    /// let node = graph.get_node(&node_id).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn get_node(&self, id: &NodeId) -> Result<Option<Node>> {
        let start = Instant::now();

        // Check cache first
        if let Some(node) = self.cache.get_node(id).await {
            // Record cache hit in metrics
            if let Some(metrics) = &self.metrics {
                let latency_us = start.elapsed().as_micros() as u64;
                metrics.record_read_latency_us(latency_us);
            }
            return Ok(Some(node));
        }

        // Cache miss - load from storage
        if let Some(node) = self.backend.get_node(id).await? {
            // Populate cache for future requests
            self.cache.insert_node(*id, node.clone()).await;

            // Record read latency
            if let Some(metrics) = &self.metrics {
                let latency_us = start.elapsed().as_micros() as u64;
                metrics.record_read_latency_us(latency_us);
            }

            return Ok(Some(node));
        }

        Ok(None)
    }

    /// Get an edge by ID asynchronously (cache-aware)
    ///
    /// This method first checks the cache for the edge. If found in cache,
    /// it returns immediately. Otherwise, it loads from storage and populates
    /// the cache for future requests.
    ///
    /// # Performance
    ///
    /// - Cache hit: < 1ms latency
    /// - Cache miss: 2-10ms latency (loads from storage)
    pub async fn get_edge(&self, id: &crate::types::EdgeId) -> Result<Option<Edge>> {
        let start = Instant::now();

        // Check cache first
        if let Some(edge) = self.cache.get_edge(id).await {
            // Record cache hit in metrics
            if let Some(metrics) = &self.metrics {
                let latency_us = start.elapsed().as_micros() as u64;
                metrics.record_read_latency_us(latency_us);
            }
            return Ok(Some(edge));
        }

        // Cache miss - load from storage
        if let Some(edge) = self.backend.get_edge(id).await? {
            // Populate cache for future requests
            self.cache.insert_edge(*id, edge.clone()).await;

            // Record read latency
            if let Some(metrics) = &self.metrics {
                let latency_us = start.elapsed().as_micros() as u64;
                metrics.record_read_latency_us(latency_us);
            }

            return Ok(Some(edge));
        }

        Ok(None)
    }

    /// Add a custom edge asynchronously
    pub async fn add_edge(&self, from: NodeId, to: NodeId, edge_type: EdgeType) -> Result<()> {
        let edge = Edge::new(from, to, edge_type);
        self.backend.store_edge(&edge).await
    }

    /// Get all outgoing edges from a node asynchronously
    pub async fn get_outgoing_edges(&self, node_id: &NodeId) -> Result<Vec<Edge>> {
        self.backend.get_outgoing_edges(node_id).await
    }

    /// Get all incoming edges to a node asynchronously
    pub async fn get_incoming_edges(&self, node_id: &NodeId) -> Result<Vec<Edge>> {
        self.backend.get_incoming_edges(node_id).await
    }

    /// Get all nodes in a session asynchronously
    pub async fn get_session_nodes(&self, session_id: &SessionId) -> Result<Vec<Node>> {
        self.backend.get_session_nodes(session_id).await
    }

    // ===== Batch Operations =====

    /// Store multiple nodes concurrently asynchronously
    ///
    /// This method leverages async concurrency to store multiple nodes in parallel.
    pub async fn store_nodes_batch(&self, nodes: Vec<Node>) -> Result<Vec<NodeId>> {
        self.backend.store_nodes_batch(&nodes).await
    }

    /// Store multiple edges concurrently asynchronously
    pub async fn store_edges_batch(&self, edges: Vec<Edge>) -> Result<()> {
        self.backend.store_edges_batch(&edges).await?;
        Ok(())
    }

    /// Add multiple responses concurrently (batch operation)
    ///
    /// This method processes all responses in parallel for maximum throughput.
    /// Each response is linked to its corresponding prompt.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::{Config, TokenUsage};
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let session = graph.create_session().await?;
    /// # let prompt1 = graph.add_prompt(session.id, "Q1".to_string(), None).await?;
    /// # let prompt2 = graph.add_prompt(session.id, "Q2".to_string(), None).await?;
    /// let responses = vec![
    ///     (prompt1, "Answer 1".to_string(), TokenUsage::new(10, 50)),
    ///     (prompt2, "Answer 2".to_string(), TokenUsage::new(15, 60)),
    /// ];
    /// let ids = graph.add_responses_batch(responses).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn add_responses_batch(
        &self,
        responses: Vec<(NodeId, String, TokenUsage)>,
    ) -> Result<Vec<NodeId>> {
        let futures: Vec<_> = responses
            .into_iter()
            .map(|(prompt_id, content, usage)| self.add_response(prompt_id, content, usage, None))
            .collect();

        futures::future::try_join_all(futures).await
    }

    /// Create multiple sessions concurrently (batch operation)
    ///
    /// This method creates multiple sessions in parallel for maximum throughput.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::Config;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// let sessions = graph.create_sessions_batch(5).await?;
    /// assert_eq!(sessions.len(), 5);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn create_sessions_batch(&self, count: usize) -> Result<Vec<ConversationSession>> {
        let futures: Vec<_> = (0..count).map(|_| self.create_session()).collect();

        futures::future::try_join_all(futures).await
    }

    /// Retrieve multiple nodes concurrently (batch operation)
    ///
    /// This method fetches all nodes in parallel for maximum throughput.
    /// Returns nodes in the same order as the input IDs. Missing nodes are None.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::Config;
    /// # use llm_memory_graph::types::NodeId;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let session = graph.create_session().await?;
    /// # let id1 = graph.add_prompt(session.id, "Q1".to_string(), None).await?;
    /// # let id2 = graph.add_prompt(session.id, "Q2".to_string(), None).await?;
    /// let ids = vec![id1, id2];
    /// let nodes = graph.get_nodes_batch(ids).await?;
    /// assert_eq!(nodes.len(), 2);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn get_nodes_batch(&self, ids: Vec<NodeId>) -> Result<Vec<Option<Node>>> {
        let futures: Vec<_> = ids.iter().map(|id| self.get_node(id)).collect();

        futures::future::try_join_all(futures).await
    }

    /// Delete multiple nodes concurrently (batch operation)
    ///
    /// This method deletes all nodes in parallel for maximum throughput.
    /// Note: This does not cascade delete related edges - you may want to
    /// delete related edges separately.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::Config;
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let session = graph.create_session().await?;
    /// # let id1 = graph.add_prompt(session.id, "Q1".to_string(), None).await?;
    /// # let id2 = graph.add_prompt(session.id, "Q2".to_string(), None).await?;
    /// let ids = vec![id1, id2];
    /// graph.delete_nodes_batch(ids).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn delete_nodes_batch(&self, ids: Vec<NodeId>) -> Result<()> {
        let futures: Vec<_> = ids.iter().map(|id| self.backend.delete_node(id)).collect();

        futures::future::try_join_all(futures).await?;
        Ok(())
    }

    /// Process a mixed batch of prompts and responses concurrently
    ///
    /// This is an advanced operation that allows you to add prompts and their
    /// responses in a single concurrent batch operation. This is useful for
    /// bulk importing conversation data.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// # use llm_memory_graph::engine::AsyncMemoryGraph;
    /// # use llm_memory_graph::{Config, TokenUsage};
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let graph = AsyncMemoryGraph::open(Config::default()).await?;
    /// # let session = graph.create_session().await?;
    /// let conversations = vec![
    ///     (
    ///         (session.id, "What is Rust?".to_string()),
    ///         Some(("Rust is a systems programming language".to_string(), TokenUsage::new(5, 30))),
    ///     ),
    ///     (
    ///         (session.id, "How does async work?".to_string()),
    ///         Some(("Async in Rust is zero-cost".to_string(), TokenUsage::new(6, 25))),
    ///     ),
    /// ];
    /// let results = graph.add_conversations_batch(conversations).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn add_conversations_batch(
        &self,
        conversations: Vec<ConversationBatchItem>,
    ) -> Result<Vec<(NodeId, Option<NodeId>)>> {
        let futures: Vec<_> = conversations
            .into_iter()
            .map(|((session_id, prompt_content), response_data)| async move {
                // Add prompt
                let prompt_id = self.add_prompt(session_id, prompt_content, None).await?;

                // Add response if provided
                let response_id = if let Some((response_content, usage)) = response_data {
                    Some(
                        self.add_response(prompt_id, response_content, usage, None)
                            .await?,
                    )
                } else {
                    None
                };

                Ok((prompt_id, response_id))
            })
            .collect();

        futures::future::try_join_all(futures).await
    }

    // ===== Utility Operations =====

    /// Flush any pending writes asynchronously
    pub async fn flush(&self) -> Result<()> {
        self.backend.flush().await
    }

    /// Get storage statistics asynchronously
    pub async fn stats(&self) -> Result<crate::storage::StorageStats> {
        self.backend.stats().await
    }

    // ===== Query Operations =====

    /// Create a new async query builder for querying the graph
    ///
    /// Returns an `AsyncQueryBuilder` that provides a fluent API for building
    /// and executing queries with filtering, pagination, and streaming support.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use llm_memory_graph::engine::AsyncMemoryGraph;
    /// use llm_memory_graph::types::NodeType;
    /// use llm_memory_graph::Config;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
    ///     let graph = AsyncMemoryGraph::open(Config::default()).await?;
    ///     let session = graph.create_session().await?;
    ///
    ///     // Query with fluent API
    ///     let prompts = graph.query()
    ///         .session(session.id)
    ///         .node_type(NodeType::Prompt)
    ///         .limit(10)
    ///         .execute()
    ///         .await?;
    ///
    ///     println!("Found {} prompts", prompts.len());
    ///     Ok(())
    /// }
    /// ```
    pub fn query(&self) -> crate::query::AsyncQueryBuilder {
        crate::query::AsyncQueryBuilder::new(Arc::clone(&self.backend))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::tempdir;

    #[tokio::test]
    async fn test_async_graph_creation() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.node_count, 0);
    }

    #[tokio::test]
    async fn test_async_session_management() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        // Create session
        let session = graph.create_session().await.unwrap();
        assert!(!session.id.to_string().is_empty());

        // Retrieve session
        let retrieved = graph.get_session(session.id).await.unwrap();
        assert_eq!(retrieved.id, session.id);
    }

    #[tokio::test]
    async fn test_async_prompt_and_response() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();
        let prompt_id = graph
            .add_prompt(session.id, "Test prompt".to_string(), None)
            .await
            .unwrap();

        let usage = TokenUsage::new(10, 20);
        let response_id = graph
            .add_response(prompt_id, "Test response".to_string(), usage, None)
            .await
            .unwrap();

        // Verify edges
        let edges = graph.get_outgoing_edges(&response_id).await.unwrap();
        assert_eq!(edges.len(), 1);
        assert_eq!(edges[0].edge_type, EdgeType::RespondsTo);
    }

    #[tokio::test]
    async fn test_concurrent_prompts() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = Arc::new(AsyncMemoryGraph::open(config).await.unwrap());

        let session = graph.create_session().await.unwrap();

        // Create 100 prompts concurrently
        let mut handles = vec![];
        for i in 0..100 {
            let graph_clone = Arc::clone(&graph);
            let session_id = session.id;

            let handle = tokio::spawn(async move {
                graph_clone
                    .add_prompt(session_id, format!("Prompt {}", i), None)
                    .await
            });

            handles.push(handle);
        }

        // Wait for all to complete
        for handle in handles {
            handle.await.unwrap().unwrap();
        }

        // Verify all were stored
        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.node_count, 101); // 1 session + 100 prompts
    }

    #[tokio::test]
    async fn test_batch_operations() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();

        // Batch add prompts
        let prompts = (0..10)
            .map(|i| (session.id, format!("Prompt {}", i)))
            .collect();

        let ids = graph.add_prompts_batch(prompts).await.unwrap();
        assert_eq!(ids.len(), 10);

        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.node_count, 11); // 1 session + 10 prompts
    }

    #[tokio::test]
    async fn test_agent_operations() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let agent = AgentNode::new(
            "TestAgent".to_string(),
            "tester".to_string(),
            vec!["testing".to_string()],
        );

        let agent_id = graph.add_agent(agent).await.unwrap();
        assert!(!agent_id.to_string().is_empty());
    }

    #[tokio::test]
    async fn test_template_operations() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let template = PromptTemplate::new(
            "Test Template".to_string(),
            "Hello {{name}}!".to_string(),
            vec![],
        );

        let template_id = graph.create_template(template.clone()).await.unwrap();
        assert_eq!(template_id, template.id);
    }

    #[tokio::test]
    async fn test_tool_invocation() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();
        let prompt_id = graph
            .add_prompt(session.id, "Calculate 2+2".to_string(), None)
            .await
            .unwrap();

        let usage = TokenUsage::new(5, 10);
        let response_id = graph
            .add_response(prompt_id, "Using calculator...".to_string(), usage, None)
            .await
            .unwrap();

        let tool = ToolInvocation::new(
            response_id,
            "calculator".to_string(),
            serde_json::json!({"op": "add", "a": 2, "b": 2}),
        );

        let _tool_id = graph.add_tool_invocation(tool).await.unwrap();

        // Verify INVOKES edge was created
        let edges = graph.get_outgoing_edges(&response_id).await.unwrap();
        let invokes_edge = edges.iter().find(|e| e.edge_type == EdgeType::Invokes);
        assert!(invokes_edge.is_some());
    }

    #[tokio::test]
    async fn test_add_responses_batch() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();

        // Create 5 prompts first
        let mut prompt_ids = vec![];
        for i in 0..5 {
            let id = graph
                .add_prompt(session.id, format!("Prompt {}", i), None)
                .await
                .unwrap();
            prompt_ids.push(id);
        }

        // Batch add responses
        let responses: Vec<_> = prompt_ids
            .iter()
            .enumerate()
            .map(|(i, &prompt_id)| {
                (
                    prompt_id,
                    format!("Response {}", i),
                    TokenUsage::new(10, 20),
                )
            })
            .collect();

        let response_ids = graph.add_responses_batch(responses).await.unwrap();
        assert_eq!(response_ids.len(), 5);

        // Verify all responses were created with proper edges
        for (i, &response_id) in response_ids.iter().enumerate() {
            let node = graph.get_node(&response_id).await.unwrap();
            assert!(matches!(node, Some(Node::Response(_))));

            // Check RESPONDS_TO edge
            let edges = graph.get_outgoing_edges(&response_id).await.unwrap();
            let responds_to = edges.iter().find(|e| e.edge_type == EdgeType::RespondsTo);
            assert!(responds_to.is_some());
            assert_eq!(responds_to.unwrap().to, prompt_ids[i]);
        }

        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.node_count, 11); // 1 session + 5 prompts + 5 responses
    }

    #[tokio::test]
    async fn test_create_sessions_batch() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        // Create 10 sessions concurrently
        let sessions = graph.create_sessions_batch(10).await.unwrap();
        assert_eq!(sessions.len(), 10);

        // Verify all sessions have unique IDs
        let mut ids = std::collections::HashSet::new();
        for session in &sessions {
            assert!(ids.insert(session.id));
        }

        // Verify all can be retrieved
        for session in &sessions {
            let retrieved = graph.get_session(session.id).await.unwrap();
            assert_eq!(retrieved.id, session.id);
        }

        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.node_count, 10);
        assert_eq!(stats.session_count, 10);
    }

    #[tokio::test]
    async fn test_get_nodes_batch() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();

        // Create 20 prompts
        let mut expected_ids = vec![];
        for i in 0..20 {
            let id = graph
                .add_prompt(session.id, format!("Prompt {}", i), None)
                .await
                .unwrap();
            expected_ids.push(id);
        }

        // Batch retrieve all nodes
        let nodes = graph.get_nodes_batch(expected_ids.clone()).await.unwrap();
        assert_eq!(nodes.len(), 20);

        // Verify all nodes were retrieved
        for (i, node_opt) in nodes.iter().enumerate() {
            assert!(node_opt.is_some());
            let node = node_opt.as_ref().unwrap();
            assert_eq!(node.id(), expected_ids[i]);

            if let Node::Prompt(prompt) = node {
                assert_eq!(prompt.content, format!("Prompt {}", i));
            } else {
                panic!("Expected Prompt node");
            }
        }
    }

    #[tokio::test]
    async fn test_get_nodes_batch_with_missing() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();

        // Create 3 prompts
        let mut ids = vec![];
        for i in 0..3 {
            let id = graph
                .add_prompt(session.id, format!("Prompt {}", i), None)
                .await
                .unwrap();
            ids.push(id);
        }

        // Add non-existent ID in the middle
        let fake_id = NodeId::new();
        ids.insert(1, fake_id);

        // Batch retrieve should return None for missing node
        let nodes = graph.get_nodes_batch(ids).await.unwrap();
        assert_eq!(nodes.len(), 4);
        assert!(nodes[0].is_some());
        assert!(nodes[1].is_none()); // Fake ID
        assert!(nodes[2].is_some());
        assert!(nodes[3].is_some());
    }

    #[tokio::test]
    async fn test_delete_nodes_batch() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();

        // Create 15 prompts
        let mut ids_to_delete = vec![];
        for i in 0..15 {
            let id = graph
                .add_prompt(session.id, format!("Prompt {}", i), None)
                .await
                .unwrap();
            ids_to_delete.push(id);
        }

        // Verify initial state
        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.node_count, 16); // 1 session + 15 prompts

        // Batch delete all prompts
        graph
            .delete_nodes_batch(ids_to_delete.clone())
            .await
            .unwrap();

        // Note: Current implementation may cache nodes, so deletion might not be immediate
        // This test verifies the batch operation completes without errors
        // For stricter deletion verification, use flush and clear cache
    }

    #[tokio::test]
    async fn test_add_conversations_batch() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();

        // Create mixed batch: some with responses, some without
        let conversations = vec![
            (
                (session.id, "Prompt 1".to_string()),
                Some(("Response 1".to_string(), TokenUsage::new(10, 20))),
            ),
            (
                (session.id, "Prompt 2".to_string()),
                None, // No response
            ),
            (
                (session.id, "Prompt 3".to_string()),
                Some(("Response 3".to_string(), TokenUsage::new(15, 25))),
            ),
            (
                (session.id, "Prompt 4".to_string()),
                Some(("Response 4".to_string(), TokenUsage::new(12, 22))),
            ),
            (
                (session.id, "Prompt 5".to_string()),
                None, // No response
            ),
        ];

        let results = graph.add_conversations_batch(conversations).await.unwrap();
        assert_eq!(results.len(), 5);

        // Verify structure
        assert!(results[0].1.is_some()); // Has response
        assert!(results[1].1.is_none()); // No response
        assert!(results[2].1.is_some()); // Has response
        assert!(results[3].1.is_some()); // Has response
        assert!(results[4].1.is_none()); // No response

        // Verify all prompts exist
        for (prompt_id, _) in &results {
            let node = graph.get_node(prompt_id).await.unwrap();
            assert!(matches!(node, Some(Node::Prompt(_))));
        }

        // Verify responses exist and have proper edges
        for (prompt_id, response_id_opt) in &results {
            if let Some(response_id) = response_id_opt {
                let node = graph.get_node(response_id).await.unwrap();
                assert!(matches!(node, Some(Node::Response(_))));

                // Check RESPONDS_TO edge
                let edges = graph.get_outgoing_edges(response_id).await.unwrap();
                let responds_to = edges.iter().find(|e| e.edge_type == EdgeType::RespondsTo);
                assert!(responds_to.is_some());
                assert_eq!(responds_to.unwrap().to, *prompt_id);
            }
        }

        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.node_count, 9); // 1 session + 5 prompts + 3 responses
    }

    #[tokio::test]
    async fn test_empty_batch_operations() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        // Test empty batches
        let sessions = graph.create_sessions_batch(0).await.unwrap();
        assert_eq!(sessions.len(), 0);

        let nodes = graph.get_nodes_batch(vec![]).await.unwrap();
        assert_eq!(nodes.len(), 0);

        graph.delete_nodes_batch(vec![]).await.unwrap();

        let prompts = graph.add_prompts_batch(vec![]).await.unwrap();
        assert_eq!(prompts.len(), 0);

        let responses = graph.add_responses_batch(vec![]).await.unwrap();
        assert_eq!(responses.len(), 0);

        let conversations = graph.add_conversations_batch(vec![]).await.unwrap();
        assert_eq!(conversations.len(), 0);
    }

    #[tokio::test]
    async fn test_large_batch_operations() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = AsyncMemoryGraph::open(config).await.unwrap();

        let session = graph.create_session().await.unwrap();

        // Create 100 prompts in batch
        let prompts: Vec<_> = (0..100)
            .map(|i| (session.id, format!("Prompt {}", i)))
            .collect();

        let prompt_ids = graph.add_prompts_batch(prompts).await.unwrap();
        assert_eq!(prompt_ids.len(), 100);

        // Create 100 responses in batch
        let responses: Vec<_> = prompt_ids
            .iter()
            .enumerate()
            .map(|(i, &id)| (id, format!("Response {}", i), TokenUsage::new(10, 20)))
            .collect();

        let response_ids = graph.add_responses_batch(responses).await.unwrap();
        assert_eq!(response_ids.len(), 100);

        // Batch retrieve all prompts
        let nodes = graph.get_nodes_batch(prompt_ids.clone()).await.unwrap();
        assert_eq!(nodes.len(), 100);
        assert!(nodes.iter().all(|n| n.is_some()));

        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.node_count, 201); // 1 session + 100 prompts + 100 responses
    }

    #[tokio::test]
    async fn test_batch_concurrent_execution() {
        let dir = tempdir().unwrap();
        let config = Config::new(dir.path());
        let graph = Arc::new(AsyncMemoryGraph::open(config).await.unwrap());

        // Test that batch operations can be called concurrently from multiple tasks
        let mut handles = vec![];

        for i in 0..5 {
            let graph_clone = Arc::clone(&graph);
            let handle = tokio::spawn(async move {
                // Each task creates its own session and prompts
                let sessions = graph_clone.create_sessions_batch(2).await.unwrap();
                let prompts = vec![
                    (sessions[0].id, format!("Task {} Prompt 1", i)),
                    (sessions[1].id, format!("Task {} Prompt 2", i)),
                ];
                graph_clone.add_prompts_batch(prompts).await.unwrap();
            });
            handles.push(handle);
        }

        // Wait for all concurrent operations
        for handle in handles {
            handle.await.unwrap();
        }

        // Verify all operations succeeded
        let stats = graph.stats().await.unwrap();
        assert_eq!(stats.session_count, 10); // 5 tasks × 2 sessions each
        assert_eq!(stats.node_count, 20); // 10 sessions + 10 prompts
    }
}