rag-module 0.6.7

Enterprise RAG module with chat context storage, vector search, session management, and model downloading. Rust implementation with Node.js compatibility.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Service registry configuration for operation context

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServiceRegistry {
    pub services: HashMap<String, ServiceDefinition>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServiceDefinition {
    pub name: String,
    pub description: String,
    pub operations: HashMap<String, OperationConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OperationConfig {
    pub operation: String,
    pub description: String,
    pub required_params: Vec<String>,
    pub optional_params: Vec<String>,
    pub confidential_data: Vec<String>,
    pub non_confidential_data: Vec<String>,
    pub validation_rules: HashMap<String, ValidationRule>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationRule {
    #[serde(rename = "type")]
    pub rule_type: String,
    pub pattern: Option<String>,
    pub enum_values: Option<Vec<String>>,
    pub min_length: Option<usize>,
    pub max_length: Option<usize>,
}

impl ServiceRegistry {
    pub fn default() -> Self {
        let mut services = HashMap::new();

        // AWS EC2 Service
        let mut ec2_operations = HashMap::new();
        
        ec2_operations.insert("stop_instance".to_string(), OperationConfig {
            operation: "stop_instance".to_string(),
            description: "Stop an EC2 instance".to_string(),
            required_params: vec!["instance_id".to_string(), "region".to_string()],
            optional_params: vec!["force".to_string()],
            confidential_data: vec!["name".to_string(), "tags".to_string(), "security_groups".to_string()],
            non_confidential_data: vec!["region".to_string(), "state".to_string(), "instance_type".to_string()],
            validation_rules: HashMap::new(),
        });

        ec2_operations.insert("start_instance".to_string(), OperationConfig {
            operation: "start_instance".to_string(),
            description: "Start an EC2 instance".to_string(),
            required_params: vec!["instance_id".to_string(), "region".to_string()],
            optional_params: vec![],
            confidential_data: vec!["name".to_string(), "tags".to_string(), "security_groups".to_string()],
            non_confidential_data: vec!["region".to_string(), "state".to_string(), "instance_type".to_string()],
            validation_rules: HashMap::new(),
        });

        services.insert("aws_ec2".to_string(), ServiceDefinition {
            name: "aws_ec2".to_string(),
            description: "Amazon EC2 (Elastic Compute Cloud) service for managing virtual machines".to_string(),
            operations: ec2_operations,
        });

        // AWS RDS Service
        let mut rds_operations = HashMap::new();
        
        rds_operations.insert("stop_db_instance".to_string(), OperationConfig {
            operation: "stop_db_instance".to_string(),
            description: "Stop an RDS database instance".to_string(),
            required_params: vec!["db_instance_identifier".to_string(), "region".to_string()],
            optional_params: vec!["snapshot_id".to_string()],
            confidential_data: vec!["db_name".to_string(), "master_username".to_string(), "endpoint".to_string()],
            non_confidential_data: vec!["region".to_string(), "engine".to_string(), "db_instance_class".to_string()],
            validation_rules: HashMap::new(),
        });

        rds_operations.insert("start_db_instance".to_string(), OperationConfig {
            operation: "start_db_instance".to_string(),
            description: "Start an RDS database instance".to_string(),
            required_params: vec!["db_instance_identifier".to_string(), "region".to_string()],
            optional_params: vec![],
            confidential_data: vec!["db_name".to_string(), "master_username".to_string(), "endpoint".to_string()],
            non_confidential_data: vec!["region".to_string(), "engine".to_string(), "db_instance_class".to_string()],
            validation_rules: HashMap::new(),
        });

        services.insert("aws_rds".to_string(), ServiceDefinition {
            name: "aws_rds".to_string(),
            description: "Amazon RDS (Relational Database Service) for managed databases".to_string(),
            operations: rds_operations,
        });

        // AWS S3 Service
        let mut s3_operations = HashMap::new();
        
        s3_operations.insert("delete_bucket".to_string(), OperationConfig {
            operation: "delete_bucket".to_string(),
            description: "Delete an S3 bucket".to_string(),
            required_params: vec!["bucket".to_string(), "region".to_string()],
            optional_params: vec!["force".to_string()],
            confidential_data: vec!["bucket_name".to_string(), "policy".to_string()],
            non_confidential_data: vec!["region".to_string(), "versioning_status".to_string()],
            validation_rules: HashMap::new(),
        });

        services.insert("aws_s3".to_string(), ServiceDefinition {
            name: "aws_s3".to_string(),
            description: "Amazon S3 (Simple Storage Service) for object storage".to_string(),
            operations: s3_operations,
        });

        Self { services }
    }

    pub fn get_service(&self, service_name: &str) -> Option<&ServiceDefinition> {
        self.services.get(service_name)
    }

    pub fn get_operation_config(&self, service_name: &str, operation_name: &str) -> Option<&OperationConfig> {
        self.services
            .get(service_name)?
            .operations
            .get(operation_name)
    }

    pub fn get_all_services(&self) -> Vec<&str> {
        self.services.keys().map(|s| s.as_str()).collect()
    }

    pub fn get_service_operations(&self, service_name: &str) -> Vec<&str> {
        self.services
            .get(service_name)
            .map(|service| service.operations.keys().map(|op| op.as_str()).collect())
            .unwrap_or_default()
    }
}