skill-web 0.3.0

Web interface for Skill Engine - built with Yew and WebAssembly
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
141
142

//! Search API client

use super::client::ApiClient;
use super::error::ApiResult;
use super::types::*;

/// Search API operations
#[derive(Clone)]
pub struct SearchApi {
    client: ApiClient,
}

impl SearchApi {
    /// Create a new search API client
    pub fn new(client: ApiClient) -> Self {
        Self { client }
    }

    /// Perform a semantic search
    pub async fn search(&self, request: &SearchRequest) -> ApiResult<SearchResponse> {
        self.client.post("/search", request).await
    }

    /// Simple search with query string
    pub async fn query(&self, query: &str) -> ApiResult<SearchResponse> {
        self.search(&SearchRequest {
            query: query.to_string(),
            top_k: 10,
            skill_filter: None,
            include_examples: false,
        })
        .await
    }

    /// Search with limited results
    pub async fn query_top_k(&self, query: &str, top_k: usize) -> ApiResult<SearchResponse> {
        self.search(&SearchRequest {
            query: query.to_string(),
            top_k,
            skill_filter: None,
            include_examples: false,
        })
        .await
    }

    /// Search within a specific skill
    pub async fn search_in_skill(&self, query: &str, skill: &str) -> ApiResult<SearchResponse> {
        self.search(&SearchRequest {
            query: query.to_string(),
            top_k: 10,
            skill_filter: Some(skill.to_string()),
            include_examples: false,
        })
        .await
    }

    /// Search with AI-generated examples included
    pub async fn search_with_examples(&self, query: &str) -> ApiResult<SearchResponse> {
        self.search(&SearchRequest {
            query: query.to_string(),
            top_k: 10,
            skill_filter: None,
            include_examples: true,
        })
        .await
    }

    /// Get search configuration
    pub async fn get_config(&self) -> ApiResult<SearchConfigResponse> {
        self.client.get("/search/config").await
    }

    /// Update search configuration
    pub async fn update_config(
        &self,
        request: &UpdateSearchConfigRequest,
    ) -> ApiResult<SearchConfigResponse> {
        self.client.put("/search/config", request).await
    }

    /// Enable or disable hybrid search
    pub async fn set_hybrid_search(&self, enabled: bool) -> ApiResult<SearchConfigResponse> {
        self.update_config(&UpdateSearchConfigRequest {
            enable_hybrid: Some(enabled),
            ..Default::default()
        })
        .await
    }

    /// Enable or disable reranking
    pub async fn set_reranking(&self, enabled: bool) -> ApiResult<SearchConfigResponse> {
        self.update_config(&UpdateSearchConfigRequest {
            enable_reranking: Some(enabled),
            ..Default::default()
        })
        .await
    }

    /// Change embedding provider
    pub async fn set_embedding_provider(
        &self,
        provider: &str,
        model: Option<&str>,
    ) -> ApiResult<SearchConfigResponse> {
        self.update_config(&UpdateSearchConfigRequest {
            embedding_provider: Some(provider.to_string()),
            embedding_model: model.map(String::from),
            ..Default::default()
        })
        .await
    }

    /// Change vector backend
    pub async fn set_vector_backend(&self, backend: &str) -> ApiResult<SearchConfigResponse> {
        self.update_config(&UpdateSearchConfigRequest {
            vector_backend: Some(backend.to_string()),
            ..Default::default()
        })
        .await
    }

    /// Test search connection (quick validation)
    pub async fn test_connection(
        &self,
        request: &TestConnectionRequest,
    ) -> ApiResult<TestConnectionResponse> {
        self.client.post("/search/test-connection", request).await
    }

    /// Test full search pipeline (indexing + search)
    pub async fn test_pipeline(
        &self,
        request: &TestPipelineRequest,
    ) -> ApiResult<TestPipelineResponse> {
        self.client.post("/search/test-pipeline", request).await
    }

    /// Index all skills into the search pipeline
    pub async fn index(&self) -> ApiResult<IndexResponse> {
        self.client.post("/search/index", &()).await
    }
}