Skip to main content

dakera_client/
lib.rs

1//! Dakera Rust Client SDK
2//!
3//! A high-level Rust client for interacting with Dakera AI Agent Memory Platform.
4//!
5//! # Quick Start (HTTP)
6//!
7//! ```rust,no_run
8//! use dakera_client::{DakeraClient, UpsertRequest, QueryRequest};
9//!
10//! #[tokio::main]
11//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
12//!     // Create a client
13//!     let client = DakeraClient::new("http://localhost:3000")?;
14//!
15//!     // Check health
16//!     let health = client.health().await?;
17//!     println!("Server healthy: {}", health.healthy);
18//!
19//!     // Upsert vectors
20//!     let request = UpsertRequest {
21//!         vectors: vec![
22//!             dakera_client::Vector {
23//!                 id: "vec1".to_string(),
24//!                 values: vec![0.1, 0.2, 0.3, 0.4],
25//!                 metadata: None,
26//!             },
27//!         ],
28//!     };
29//!     client.upsert("my-namespace", request).await?;
30//!
31//!     // Query for similar vectors
32//!     let query = QueryRequest {
33//!         vector: vec![0.1, 0.2, 0.3, 0.4],
34//!         top_k: 10,
35//!         filter: None,
36//!         include_metadata: true,
37//!         include_vectors: false,
38//!         distance_metric: Default::default(),
39//!         consistency: Default::default(),
40//!         staleness_config: None,
41//!     };
42//!     let results = client.query("my-namespace", query).await?;
43//!
44//!     for match_ in results.results {
45//!         println!("ID: {}, Score: {}", match_.id, match_.score);
46//!     }
47//!
48//!     Ok(())
49//! }
50//! ```
51//!
52//! # gRPC Client with Connection Pooling
53//!
54//! Enable the `grpc` feature for high-performance gRPC communication:
55//!
56//! ```rust,ignore
57//! use dakera_client::grpc::{GrpcClient, GrpcClientConfig, GrpcConnectionPool};
58//!
59//! #[tokio::main]
60//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
61//!     // Single client with HTTP/2 multiplexing
62//!     let config = GrpcClientConfig::default()
63//!         .with_endpoint("http://localhost:50051")
64//!         .with_concurrency_limit(100);
65//!     let client = GrpcClient::connect(config).await?;
66//!
67//!     // Or use a connection pool for even higher throughput
68//!     let pool = GrpcConnectionPool::new(GrpcClientConfig::default(), 4).await?;
69//!     let client = pool.get();
70//!
71//!     Ok(())
72//! }
73//! ```
74
75pub mod admin;
76pub mod agents;
77pub mod analytics;
78#[cfg(feature = "http-client")]
79mod client;
80mod error;
81pub mod events;
82pub mod filter;
83pub mod keys;
84pub mod knowledge;
85pub mod memory;
86pub mod session;
87mod types;
88
89// gRPC client with connection pooling
90#[cfg(feature = "grpc")]
91mod grpc_client;
92#[cfg(feature = "grpc")]
93mod grpc_proto;
94
95pub use events::{DakeraEvent, MemoryEvent, OpStatus, VectorMutationOp};
96
97pub use admin::{
98    AutoPilotConfig, AutoPilotConfigRequest, AutoPilotConfigResponse, AutoPilotConsolidationResult,
99    AutoPilotDedupResult, AutoPilotStatusResponse, AutoPilotTriggerAction, AutoPilotTriggerRequest,
100    AutoPilotTriggerResponse, BackupInfo, BackupListResponse, CacheStats, ClearCacheRequest,
101    ClearCacheResponse, ClusterStatus, ConsolidationResultSnapshot, CreateBackupRequest,
102    CreateBackupResponse, DecayConfigResponse, DecayConfigUpdateRequest, DecayConfigUpdateResponse,
103    DecayStatsResponse, DedupResultSnapshot, FulltextReindexNamespaceResult,
104    FulltextReindexResponse, IndexStats, IndexStatsResponse, KpiSnapshot, LastDecayCycleStats,
105    NodeInfo, NodeListResponse, OpsStats, QuotaConfig, QuotaListResponse, QuotaStatus,
106    RestoreBackupRequest, RestoreBackupResponse, RuntimeConfig, SlowQueryListResponse,
107    TtlCleanupRequest, TtlCleanupResponse, TtlStats, TtlStatsResponse,
108};
109pub use agents::{AgentStats, AgentSummary, CompressResponse, Memory, WakeUpResponse};
110pub use analytics::{AnalyticsOverview, LatencyAnalytics, StorageAnalytics, ThroughputAnalytics};
111#[cfg(feature = "http-client")]
112pub use client::{DakeraClient, DakeraClientBuilder};
113pub use error::{ClientError, Result};
114pub use keys::{
115    ApiKeyUsageResponse, CreateKeyRequest, CreateKeyResponse, CreateNamespaceKeyRequest,
116    CreateNamespaceKeyResponse, KeyInfo, ListKeysResponse, ListNamespaceKeysResponse,
117    NamespaceKeyInfo, NamespaceKeyUsageResponse, RotateKeyResponse,
118};
119pub use knowledge::{
120    AgentNetworkEdge, AgentNetworkInfo, AgentNetworkNode, AgentNetworkStats,
121    CrossAgentNetworkRequest, CrossAgentNetworkResponse, DeduplicateRequest, DeduplicateResponse,
122    FullKnowledgeGraphRequest, KnowledgeEdge, KnowledgeGraphRequest, KnowledgeGraphResponse,
123    KnowledgeNode, SummarizeRequest, SummarizeResponse,
124};
125pub use memory::{
126    // OBS-1: Business-Event Audit Log
127    AuditEvent,
128    AuditExportResponse,
129    AuditListResponse,
130    AuditQuery,
131    BatchForgetRequest,
132    BatchForgetResponse,
133    BatchMemoryFilter,
134    BatchRecallRequest,
135    BatchRecallResponse,
136    // CE-6: DBSCAN Adaptive Consolidation
137    ConsolidationConfig,
138    ConsolidationLogEntry,
139    ExtractionProviderInfo,
140    // EXT-1: External Extraction Providers
141    ExtractionResult,
142    ForgetRequest,
143    ForgetResponse,
144    MemoryExportResponse,
145    // DX-1: Memory Import / Export
146    MemoryImportResponse,
147    MemoryType,
148    RecallRequest,
149    RecallResponse,
150    RecalledMemory,
151    // SEC-3: AES-256-GCM Encryption Key Rotation
152    RotateEncryptionKeyRequest,
153    RotateEncryptionKeyResponse,
154    // CE-10: Routing mode
155    RoutingMode,
156    Session,
157    SessionEndResponse,
158    SessionStartResponse,
159    StoreMemoryRequest,
160    StoreMemoryResponse,
161};
162#[cfg(feature = "http-client")]
163pub use session::ChatMemorySession;
164pub use types::*;
165
166// gRPC exports
167#[cfg(feature = "grpc")]
168pub mod grpc {
169    //! gRPC client with connection pooling for high-performance scenarios.
170    pub use crate::grpc_client::{GrpcClient, GrpcClientConfig, GrpcConnectionPool, PoolStats};
171    pub use crate::grpc_proto::*;
172}
173
174// Re-export reqwest for CLI and other consumers
175#[cfg(feature = "http-client")]
176pub use reqwest;