reasoninglayer 0.1.2

Rust client SDK for the Reasoning Layer API
Documentation 
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

//! Community detection DTOs.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum CommunitySearchModeDto {
    ByEntities { entity_ids: Vec<String> },
    ByImpact,
    ByLevel { level: u32 },
    ByKeyword { keyword: String },
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CommunityDetectionConfigDto {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub min_community_size: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_levels: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resolution: Option<f64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommunityReportDto {
    pub id: String,
    pub impact_score: f64,
    #[serde(default)]
    pub key_findings: Vec<String>,
    pub summary: String,
    pub title: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommunityReportSummaryDto {
    pub impact_score: f64,
    pub summary: String,
    pub title: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommunityDto {
    pub id: String,
    pub level: u32,
    pub member_count: u64,
    #[serde(default)]
    pub member_ids: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub report: Option<CommunityReportDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CommunityDetectionStatsDto {
    pub avg_community_size: f64,
    pub communities_detected: u64,
    pub edges_in_graph: u64,
    pub max_community_size: u64,
    pub processing_time_ms: u64,
    pub reports_generated: u64,
    pub singleton_terms: u64,
    pub terms_in_communities: u64,
    pub terms_processed: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MembershipDto {
    pub community_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub community_title: Option<String>,
    pub degree: f64,
    pub level: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommunityMatchDto {
    pub community_id: String,
    pub level: u32,
    pub member_count: u64,
    pub relevance_score: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub report_summary: Option<CommunityReportSummaryDto>,
    #[serde(default)]
    pub sample_member_ids: Vec<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CommunitySearchStatsDto {
    pub communities_searched: u64,
    pub matches_found: u64,
    pub search_time_ms: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DetectCommunitiesRequest {
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub term_ids: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<CommunityDetectionConfigDto>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct DetectCommunitiesResponse {
    pub success: bool,
    #[serde(default)]
    pub stats: CommunityDetectionStatsDto,
    #[serde(default)]
    pub communities: Vec<CommunityDto>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GetMembershipsRequest {
    pub term_id: String,
    pub tenant_id: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GetMembershipsResponse {
    pub term_id: String,
    #[serde(default)]
    pub memberships: Vec<MembershipDto>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchCommunitiesRequest {
    pub tenant_id: String,
    pub search_mode: CommunitySearchModeDto,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_results: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub min_impact_score: Option<f64>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SearchCommunitiesResponse {
    #[serde(default)]
    pub communities: Vec<CommunityMatchDto>,
    #[serde(default)]
    pub stats: CommunitySearchStatsDto,
}