ayda 1.1.1

Ask your Documents Anything. A tool for querying your documents with a large language model.
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

use chrono::{DateTime, Utc};
use serde::{Deserialize, Deserializer, Serialize};

use crate::anythingllm::workspace::ChatMode;

/// Represents a workspace.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct Workspace {
    pub id: u32,
    pub name: String,
    pub slug: String,
    #[serde(rename = "createdAt", deserialize_with = "deserialize_utc_date")]
    pub created_at: DateTime<Utc>,
    #[serde(rename = "lastUpdatedAt", deserialize_with = "deserialize_utc_date")]
    pub last_updated_at: DateTime<Utc>,
    #[serde(rename = "similarityThreshold")]
    pub similarity_threshold: f64,
    #[serde(rename = "chatMode")]
    pub chat_mode: ChatMode,
    pub documents: Option<Vec<WorkspaceDocument>>,
}

/// Represents a workspace document.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct WorkspaceDocument {
    pub id: u32,
    #[serde(rename = "docId")]
    pub doc_id: String,
    #[serde(rename = "workspaceId")]
    pub workspace_id: u32,
    #[serde(rename = "createdAt", deserialize_with = "deserialize_utc_date")]
    pub created_at: DateTime<Utc>,
    #[serde(rename = "lastUpdatedAt", deserialize_with = "deserialize_utc_date")]
    pub last_updated_at: DateTime<Utc>,
    pub docpath: String,
    pub filename: String,
    pub pinned: bool,
    #[serde(deserialize_with = "deserialize_meta_json")]
    pub metadata: WorkspaceDocumentMetadata,
}

/// Represents the metadata of a workspace document.
#[derive(Debug, serde::Deserialize, Clone)]
pub struct WorkspaceDocumentMetadata {
    pub id: String,
    pub url: String,
    pub title: String,
    #[serde(rename = "docAuthor")]
    pub doc_author: String,
    #[serde(rename = "docSource")]
    pub doc_source: String,
    #[serde(rename = "chunkSource")]
    pub chunk_source: String,
    pub description: String,
    // #[serde(deserialize_with = "deserialize_utc_date")]
    // pub published: DateTime<Utc>,
    #[serde(rename = "wordCount")]
    pub word_count: u32,
}

/// Structure to deserialize the response from the API.
#[derive(Debug, serde::Deserialize)]
pub struct GetWorkspacesResponse {
    pub workspaces: Vec<Workspace>,
}

/// Structure to deserialize the response from the API.
#[derive(Debug, serde::Deserialize)]
pub struct GetWorkspaceNewResponse {
    pub workspace: Workspace,
    pub message: Option<String>,
}

/// Structure to deserialize the response from the API.
#[derive(Debug, serde::Deserialize)]
pub struct GetWorkspaceSlugResponse {
    pub workspace: Option<Workspace>,
}

/// Structure to deserialize the response from the API.
#[derive(Debug, serde::Deserialize, Serialize)]
pub struct PostWorkspaceSlugChatResponse {
    pub id: Option<String>,
    pub close: bool,
    pub error: Option<bool>,
    pub sources: Vec<Source>,
    #[serde(rename = "textResponse")]
    pub text_response: String,
    #[serde(rename = "type")]
    pub response_type: String,
    #[serde(rename = "chatId")]
    pub chat_id: Option<u32>,
}

/// Represents a document source.
#[derive(Debug, serde::Deserialize, Serialize)]
pub struct Source {
    #[serde(rename = "chunkSource")]
    pub chunk_source: String,
    pub description: String,
    #[serde(rename = "docAuthor")]
    pub doc_author: String,
    #[serde(rename = "docSource")]
    pub doc_source: String,
    pub id: String,
    pub published: String,
    pub score: f64,
    pub text: String,
    pub title: String,
    pub token_count_estimate: u32,
    pub url: String,
    #[serde(rename = "wordCount")]
    pub word_count: u32,
}

fn deserialize_utc_date<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
where
    D: Deserializer<'de>,
{
    let date_str = String::deserialize(deserializer)?;
    match DateTime::parse_from_rfc3339(&date_str) {
        Ok(datetime) => Ok(datetime.into()),
        Err(_) => Err(serde::de::Error::custom("Invalid date format")),
    }
}

fn deserialize_meta_json<'de, D>(deserializer: D) -> Result<WorkspaceDocumentMetadata, D::Error>
where
    D: Deserializer<'de>,
{
    let meta_str = String::deserialize(deserializer)?;
    match serde_json::from_str(&meta_str) {
        Ok(meta) => Ok(meta),
        Err(_) => Err(serde::de::Error::custom("Invalid metadata format")),
    }
}