tarzi 0.2.2

Rust-native lite search for AI applications
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

//! Serper (Google) Search API client and JSON parser.

use crate::Result;
use crate::constants::SERPER_API_URL;
use crate::error::TarziError;
use crate::fetcher::WebFetcher;
use crate::search::types::SearchResult;
use serde_json::{Value, json};

const SERPER_API_KEY_HEADER: &str = "X-API-KEY";

/// Perform a Serper web search and parse organic results.
pub async fn search_serper_api(
    fetcher: &WebFetcher,
    query: &str,
    limit: usize,
    api_key: &str,
) -> Result<Vec<SearchResult>> {
    let body = json!({
        "q": query,
        "num": limit,
    });

    let response = fetcher
        .fetch_post_json_with_headers(
            SERPER_API_URL,
            &[
                (SERPER_API_KEY_HEADER, api_key),
                ("Content-Type", "application/json"),
            ],
            &body,
        )
        .await?;

    parse_serper_api_response(&response, limit)
}

/// Parse Serper API JSON into search results (organic results).
pub fn parse_serper_api_response(json: &str, limit: usize) -> Result<Vec<SearchResult>> {
    let value: Value = serde_json::from_str(json)
        .map_err(|e| TarziError::Search(format!("Failed to parse Serper API JSON: {e}")))?;

    let results = value
        .get("organic")
        .and_then(|r| r.as_array())
        .ok_or_else(|| {
            TarziError::Search("Serper API response missing organic results".to_string())
        })?;

    let mut out = Vec::new();
    for (i, item) in results.iter().take(limit).enumerate() {
        let title = item
            .get("title")
            .and_then(|v| v.as_str())
            .unwrap_or("")
            .to_string();
        let url = item
            .get("link")
            .or_else(|| item.get("url"))
            .and_then(|v| v.as_str())
            .unwrap_or("")
            .to_string();
        let snippet = item
            .get("snippet")
            .and_then(|v| v.as_str())
            .unwrap_or("")
            .to_string();

        if title.is_empty() && url.is_empty() {
            continue;
        }

        out.push(SearchResult {
            title,
            url,
            snippet,
            rank: i + 1,
        });
    }

    Ok(out)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_serper_api_response() {
        let json = r#"{
            "organic": [
                {
                    "title": "Python.org",
                    "link": "https://www.python.org/",
                    "snippet": "The official Python website"
                },
                {
                    "title": "Python Docs",
                    "link": "https://docs.python.org/",
                    "snippet": "Documentation"
                }
            ]
        }"#;

        let results = parse_serper_api_response(json, 10).unwrap();
        assert_eq!(results.len(), 2);
        assert_eq!(results[0].title, "Python.org");
        assert_eq!(results[0].url, "https://www.python.org/");
        assert_eq!(results[0].snippet, "The official Python website");
        assert_eq!(results[0].rank, 1);
    }

    #[test]
    fn test_parse_serper_respects_limit() {
        let json = r#"{
            "organic": [
                {"title": "A", "link": "https://a.example", "snippet": "a"},
                {"title": "B", "link": "https://b.example", "snippet": "b"},
                {"title": "C", "link": "https://c.example", "snippet": "c"}
            ]
        }"#;
        let results = parse_serper_api_response(json, 1).unwrap();
        assert_eq!(results.len(), 1);
    }

    #[test]
    fn test_parse_serper_missing_organic() {
        let err = parse_serper_api_response(r#"{"searchParameters": {}}"#, 5);
        assert!(err.is_err());
    }
}