wauldo 0.3.0

Official Rust SDK for Wauldo — Verified AI answers from your documents
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

//! Document chunking and retrieval methods for AgentClient

use serde_json::json;

use crate::error::{Error, Result};
use crate::types::*;

use super::parsers::{parse_chunks, parse_retrieval_results};
use super::AgentClient;

impl AgentClient {
    /// Chunk a document
    pub async fn chunk_document(
        &mut self,
        content: &str,
        chunk_size: usize,
    ) -> Result<ChunkResult> {
        if content.trim().is_empty() {
            return Err(Error::validation_field(
                "Content cannot be empty",
                "content",
            ));
        }

        let result = self
            .call_tool(
                "manage_long_context",
                json!({
                    "operation": "chunk",
                    "content": content,
                    "chunk_size": chunk_size
                }),
            )
            .await?;

        let chunks = parse_chunks(&result);
        let total_chunks = chunks.len();
        Ok(ChunkResult {
            chunks,
            total_chunks,
            raw_content: result,
        })
    }

    /// Retrieve context for a query
    pub async fn retrieve_context(&mut self, query: &str, top_k: usize) -> Result<RetrievalResult> {
        if query.trim().is_empty() {
            return Err(Error::validation_field("Query cannot be empty", "query"));
        }

        let result = self
            .call_tool(
                "manage_long_context",
                json!({
                    "operation": "retrieve",
                    "query": query,
                    "top_k": top_k
                }),
            )
            .await?;

        let results = parse_retrieval_results(&result);
        Ok(RetrievalResult {
            query: query.to_string(),
            results,
            raw_content: result,
        })
    }

    /// Summarize content
    pub async fn summarize(&mut self, content: &str) -> Result<String> {
        if content.trim().is_empty() {
            return Err(Error::validation_field(
                "Content cannot be empty",
                "content",
            ));
        }

        self.call_tool(
            "manage_long_context",
            json!({
                "operation": "summarize",
                "content": content
            }),
        )
        .await
    }
}