Daedra

https://docs.rs/daedra/latest
Admin
Daedra is a high-performance Model Context Protocol (MCP) server that provides web search and...
Tokens:291,684
Snippets:3,177
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Search Queries

Source: https://docs.rs/daedra/latest/daedra/types/fn.visit_page_args_schema.html?search=

These are example search queries that can be used with the visit_page_args_schema. They demonstrate different search patterns.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Fetch Page Example

Source: https://docs.rs/daedra/latest/daedra/tools/fetch/fn.fetch_page.html

Demonstrates how to use the fetch_page function to retrieve content from a URL. Requires tokio runtime.

```rust
use daedra::{VisitPageArgs, tools::fetch::fetch_page};

#[tokio::main] async fn main() -> anyhow::Result<()> {
    let args = VisitPageArgs {
        url: "https://example.com".to_string(),
        selector: None,
        include_images: false,
    };
    let content = fetch_page(&args).await?;
    println!("Title: {}", content.title);
    Ok(())
}
```

--------------------------------

### Perform Search Example

Source: https://docs.rs/daedra/latest/daedra/tools/search/fn.perform_search.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the perform_search function with a query and options. Ensure you have the necessary imports and tokio runtime.

```rust
use daedra::{SearchArgs, tools::search::perform_search};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let args = SearchArgs {
        query: "Rust programming".to_string(),
        options: None,
    };
    let results = perform_search(&args).await?;
    println!("Found {} results", results.data.len());
    Ok(())
}
```

--------------------------------

### Create New FetchClient

Source: https://docs.rs/daedra/latest/daedra/tools/fetch/struct.FetchClient.html?search=std%3A%3Avec

Instantiates a new FetchClient. This is the primary way to get a FetchClient instance.

```rust
pub async fn fetch(&self, args: &VisitPageArgs) -> DaedraResult<PageContent>
```

--------------------------------

### Example Search Queries

Source: https://docs.rs/daedra/latest/daedra/types/enum.DaedraError.html?search=

Demonstrates various formats for search queries, including simple types, type conversions, and generic types with function signatures.

```text
* std::vec
* u32 -> bool
* Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Bing Backend Configuration and Client Setup

Source: https://docs.rs/daedra/latest/src/daedra/tools/bing.rs.html?search=u32+-%3E+bool

Demonstrates the creation of a new Bing backend instance, including the configuration of the HTTP client with a user agent, timeouts, and redirection policies.

```rust
pub struct BingBackend {
    client: Client,
}

impl BingBackend {
    /// Create a new Bing backend instance.
    pub fn new() -> Self {
        let client = Client::builder()
            .user_agent(USER_AGENT)
            .timeout(Duration::from_secs(30))
            .gzip(true)
            .brotli(true)
            .redirect(reqwest::redirect::Policy::limited(5))
            .build()
            .expect("Failed to build HTTP client");
        Self { client }
    }

    fn parse_results(&self, html: &str, max_results: usize) -> Vec<SearchResult> {
        let document = Html::parse_document(html);
        document
            .select(&RESULT_SELECTOR)
            .filter_map(|e| extract_bing_result(&e))
            .take(max_results)
            .collect()
    }
}
```

--------------------------------

### DaedraServer::with_defaults

Source: https://docs.rs/daedra/latest/daedra/server/struct.DaedraServer.html

Initializes a new Daedra server using default configuration settings. This is a convenient method for quick setup without specifying individual configuration options.

```APIDOC
## DaedraServer::with_defaults

### Description
Create a new server with default configuration.

### Method
`DaedraServer::with_defaults() -> DaedraResult<Self>`

### Parameters
None

### Request Example
None

### Response
#### Success Response
- **Self** (DaedraServer) - A new instance of DaedraServer with default configuration.

#### Response Example
None
```

--------------------------------

### Create New Search Client

Source: https://docs.rs/daedra/latest/daedra/tools/search/struct.SearchClient.html?search=std%3A%3Avec

Instantiates a new SearchClient. This is the primary way to get a client instance for making search requests.

```rust
pub fn new() -> DaedraResult<Self>
```

--------------------------------

### DuckDuckGo Instant Answers API Client Setup

Source: https://docs.rs/daedra/latest/src/daedra/tools/ddg_instant.rs.html

Initializes the DuckDuckGo Instant Answer backend with a configured HTTP client. Sets a custom user agent and a 10-second timeout.

```rust
pub struct DdgInstantBackend {
    client: Client,
}

impl DdgInstantBackend {
    /// Create a new DuckDuckGo Instant Answer backend instance.
    pub fn new() -> Self {
        let client = Client::builder()
            .user_agent("daedra/1.0")
            .timeout(Duration::from_secs(10))
            .build()
            .expect("HTTP client");
        Self { client }
    }
}
```

--------------------------------

### Get Server Information

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a JSON object containing server protocol version, capabilities, and server name/version. Used for server initialization.

```rust
pub fn get_server_info(&self) -> Value {
        json!({
            "protocolVersion": MCP_PROTOCOL_VERSION,
            "capabilities": {
                "tools": {}
            },
            "serverInfo": {
                "name": SERVER_NAME,
                "version": VERSION
            }
        })
    }
```

--------------------------------

### Get Cache Statistics

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=u32+-%3E+bool

Retrieves the current statistics of the server's cache.

```APIDOC
## `cache_stats(&self) -> crate::cache::CacheStats`

### Description
Returns the statistics for the Daedra server's internal cache. This can include metrics like hit rate, miss rate, and current size.

### Method
`pub fn cache_stats`

### Returns
- `crate::cache::CacheStats` - An object containing the cache statistics.
```

--------------------------------

### Get Cache Statistics

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=std%3A%3Avec

Retrieves the current statistics of the server's cache.

```APIDOC
## Get Cache Statistics

### Description
Retrieves the current statistics of the server's cache.

### Method
`pub fn cache_stats(&self) -> crate::cache::CacheStats`

### Parameters
None

### Request Example
```rust
let stats = server.cache_stats();
println!("Cache hits: {}", stats.hits);
```

### Response
#### Success Response (200)
Returns a `CacheStats` struct containing cache statistics.

#### Response Example
```rust
// Assuming CacheStats has fields like hits, misses, etc.
CacheStats { hits: 100, misses: 10, ... }
```
```

--------------------------------

### Get Search Cache Reference

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=std%3A%3Avec

Provides immutable access to the SearchCache instance.

```rust
pub fn cache(&self) -> &SearchCache {
        &self.cache
    }
```

--------------------------------

### Getting Backend Name

Source: https://docs.rs/daedra/latest/src/daedra/tools/ddg_instant.rs.html

Returns the string identifier for the DuckDuckGo Instant Answer backend.

```rust
fn name(&self) -> &str { "ddg-instant" }
```

--------------------------------

### SerperBackend::new

Source: https://docs.rs/daedra/latest/src/daedra/tools/serper.rs.html

Creates a new instance of the SerperBackend. It initializes an HTTP client with a 30-second timeout.

```APIDOC
## SerperBackend::new

### Description
Creates a new Serper backend instance. It configures an HTTP client with a specified timeout.

### Method

```rust
pub fn new(api_key: String) -> Self
```

### Parameters

- **api_key** (String) - The API key required to authenticate with the Serper.dev API.

### Returns

- `Self` - A new instance of `SerperBackend`.
```

--------------------------------

### Get TavilyBackend Name

Source: https://docs.rs/daedra/latest/daedra/tools/tavily/struct.TavilyBackend.html

Returns the name of the Tavily backend, useful for logging and diagnostics.

```rust
fn name(&self) -> &str>
```

--------------------------------

### Get Search Cache Statistics

Source: https://docs.rs/daedra/latest/daedra/cache/struct.SearchCache.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves statistics about the current state of the search cache.

```rust
pub fn stats(&self) -> CacheStats
```

--------------------------------

### Implement Any Trait

Source: https://docs.rs/daedra/latest/daedra/tools/github/struct.GitHubBackend.html?search=std%3A%3Avec

Provides a way to get the `TypeId` of `self`, enabling runtime type identification.

```rust
fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
```

--------------------------------

### Create New DdgInstantBackend

Source: https://docs.rs/daedra/latest/src/daedra/tools/ddg_instant.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a new instance of the DdgInstantBackend with a configured HTTP client, setting a user agent and a 10-second timeout.

```rust
impl DdgInstantBackend {
    /// Create a new DuckDuckGo Instant Answer backend instance.
    pub fn new() -> Self {
        let client = Client::builder()
            .user_agent("daedra/1.0")
            .timeout(Duration::from_secs(10))
            .build()
            .expect("HTTP client");
        Self { client }
    }
}
```

--------------------------------

### SerperBackend::new

Source: https://docs.rs/daedra/latest/daedra/tools/serper/struct.SerperBackend.html

Creates a new instance of the SerperBackend, which requires an API key for authentication.

```APIDOC
## SerperBackend::new

### Description
Create a new Serper backend instance.

### Method
`new`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `api_key` (String) - Required - The API key for authenticating with the Serper.dev API.
```

--------------------------------

### Dereference Pointer

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html?search=

Dereferences a raw pointer to get an immutable reference to the value. Requires `unsafe`.

```rust
unsafe fn deref<'a>(ptr: usize) -> &'a T>
```

--------------------------------

### WibyBackend::new

Source: https://docs.rs/daedra/latest/daedra/tools/wiby/struct.WibyBackend.html

Creates a new instance of the Wiby backend. This is the entry point for using the Wiby search engine.

```APIDOC
## WibyBackend::new

### Description
Create a new Wiby backend instance.

### Method
`new()`

### Returns
- `Self`: A new instance of `WibyBackend`.
```

--------------------------------

### Get Type ID of TavilyBackend

Source: https://docs.rs/daedra/latest/daedra/tools/tavily/struct.TavilyBackend.html

Retrieves the TypeId of the TavilyBackend instance, used for runtime type identification.

```rust
fn type_id(&self) -> TypeId>
```

--------------------------------

### DaedraServer::new

Source: https://docs.rs/daedra/latest/daedra/server/struct.DaedraServer.html

Creates a new Daedra server instance with the provided server configuration. This is the primary way to initialize the server with custom settings.

```APIDOC
## DaedraServer::new

### Description
Create a new Daedra server with the given configuration.

### Method
`DaedraServer::new(config: ServerConfig) -> DaedraResult<Self>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response
- **Self** (DaedraServer) - A new instance of DaedraServer.

#### Response Example
None
```

--------------------------------

### Dereference Pointer Mutably

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html?search=

Dereferences a raw pointer to get a mutable reference to the value. Requires `unsafe`.

```rust
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T>
```

--------------------------------

### Create New DuckDuckGo Instant Answer Backend

Source: https://docs.rs/daedra/latest/src/daedra/tools/ddg_instant.rs.html?search=std%3A%3Avec

Initializes a new instance of the DdgInstantBackend with a configured HTTP client. Sets a user agent and a 10-second timeout for requests.

```rust
pub fn new() -> Self {
        let client = Client::builder()
            .user_agent("daedra/1.0")
            .timeout(Duration::from_secs(10))
            .build()
            .expect("HTTP client");
        Self { client }
    }
```

--------------------------------

### Get Server Information

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=

Retrieves essential information about the Daedra server, including its protocol version and server details.

```APIDOC
## GET /server_info

### Description
Retrieves server information, including protocol version, capabilities, and server name/version.

### Method
GET

### Endpoint
/server_info

### Response
#### Success Response (200)
- **protocolVersion** (string) - The current protocol version.
- **capabilities** (object) - Server capabilities, currently includes an empty 'tools' object.
- **serverInfo** (object)
  - **name** (string) - The name of the server.
  - **version** (string) - The version of the server.

#### Response Example
```json
{
  "protocolVersion": "1.0",
  "capabilities": {
    "tools": {}
  },
  "serverInfo": {
    "name": "DaedraServer",
    "version": "0.1.0"
  }
}
```
```

--------------------------------

### SearchProvider Initialization

Source: https://docs.rs/daedra/latest/src/daedra/tools/backend.rs.html?search=u32+-%3E+bool

Constructs a new SearchProvider with a specified list of backends.

```Rust
fn from_backends(backends: Vec<Box<dyn SearchBackend>>) -> Self {
    let circuit_breakers = Self::init_circuit_breakers(&backends);
    Self {
        backends,
        rate_limiter: Self::new_rate_limiter(),
        backend_limiters: Self::new_backend_limiters(),
        backend_rate_limits: BackendRateLimiters::new(),
        circuit_breakers,
    }
}

/// Create a new provider with the given backends (in priority order).
pub fn new(backends: Vec<Box<dyn SearchBackend>>) -> Self {
    Self::from_backends(backends)
}
```

--------------------------------

### Create New DaedraServer with Defaults

Source: https://docs.rs/daedra/latest/daedra/server/struct.DaedraServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a new Daedra server instance with default configuration settings. Returns a DaeraResult.

```rust
pub fn with_defaults() -> DaedraResult<Self>
```

--------------------------------

### Error::cause Method Implementation (Deprecated)

Source: https://docs.rs/daedra/latest/daedra/types/enum.DaedraError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Deprecated method for getting the cause of the error. Replaced by Error::source.

```rust
fn cause(&self) -> Option<&dyn Error> {
    // Implementation details omitted for brevity
}
```

--------------------------------

### Check Skippable Href: Lone Colon

Source: https://docs.rs/daedra/latest/src/daedra/tools/crawl.rs.html

Tests `is_skippable_href` with a URL starting with a lone colon, which should be considered skippable.

```rust
assert!(is_skippable_href(":foo"));
```

--------------------------------

### Create New DaedraServer with Configuration

Source: https://docs.rs/daedra/latest/daedra/server/struct.DaedraServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a new Daedra server instance using a provided ServerConfig. Returns a DaedraResult.

```rust
pub fn new(config: ServerConfig) -> DaedraResult<Self>
```

--------------------------------

### Classify Content by Inference (Binary)

Source: https://docs.rs/daedra/latest/src/daedra/tools/fetch.rs.html?search=

Classifies fetched content as Binary based on file magic bytes (JPEG example).

```Rust
let bytes: &[u8] = &[0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46];
let kind = infer::get(bytes).expect("jpeg magic");
let result = classify_by_inference(&kind, bytes);
assert!(matches!(result, Some(FetchedContent::Binary { .. })));
```

--------------------------------

### DdgInstantBackend::new

Source: https://docs.rs/daedra/latest/daedra/tools/ddg_instant/struct.DdgInstantBackend.html?search=u32+-%3E+bool

Creates a new instance of the DuckDuckGo Instant Answer backend. This is the entry point for using the DDG Instant backend.

```APIDOC
## DdgInstantBackend::new

### Description
Create a new DuckDuckGo Instant Answer backend instance.

### Method
`new()`

### Returns
- `Self`: A new instance of `DdgInstantBackend`.
```

--------------------------------

### SearchProvider::new

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new SearchProvider instance with a specified order of backends.

```APIDOC
## SearchProvider::new

### Description
Creates a new provider with the given backends (in priority order).

### Method
`new`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `backends`: `Vec<Box<dyn SearchBackend>>` - A vector of boxed search backends, defining the priority order.
```

--------------------------------

### Get Server Information

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=std%3A%3Avec

Retrieves essential information about the Daedra server, including its protocol version, capabilities, and server name/version.

```APIDOC
## GET /server/info

### Description
Retrieves information about the Daedra server, such as its protocol version, capabilities, and name.

### Method
GET

### Endpoint
/server/info

### Response
#### Success Response (200)
- **protocolVersion** (string) - The current protocol version of the server.
- **capabilities** (object) - An object detailing the server's capabilities.
  - **tools** (object) - An object listing available tools.
- **serverInfo** (object) - An object containing server-specific details.
  - **name** (string) - The name of the server.
  - **version** (string) - The version of the server.

### Response Example
```json
{
  "protocolVersion": "1.0",
  "capabilities": {
    "tools": {}
  },
  "serverInfo": {
    "name": "DaedraServer",
    "version": "1.0.0"
  }
}
```
```

--------------------------------

### Create New Search Client

Source: https://docs.rs/daedra/latest/src/daedra/tools/search.rs.html?search=u32+-%3E+bool

Initializes a new HTTP client configured with a default user agent, request timeout, and support for Gzip and Brotli compression. Handles potential HTTP client build errors.

```rust
/// HTTP client for making search requests
54#[derive(Clone)]
55pub struct SearchClient {
56    client: Client,
57}
58
59impl SearchClient {
60    /// Create a new search client
61    pub fn new() -> DaedraResult<Self> {
62        let client = Client::builder()
63            .user_agent(USER_AGENT)
64            .timeout(REQUEST_TIMEOUT)
65            .gzip(true)
66            .brotli(true)
67            .build()
68            .map_err(DaedraError::HttpError)?;
69
70        Ok(Self { client })
71    }
72
73    // ... other methods
```

--------------------------------

### Get Search Arguments Schema

Source: https://docs.rs/daedra/latest/daedra/types/fn.search_args_schema.html

Returns the JSON schema for search arguments. This schema is used for MCP tool definitions.

```rust
pub fn search_args_schema() -> Value
```

--------------------------------

### Create New SearchProvider

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html?search=u32+-%3E+bool

Instantiates a new SearchProvider with a specified vector of backends in priority order.

```rust
pub fn new(backends: Vec<Box<dyn SearchBackend>>) -> Self
```

--------------------------------

### Get DaedraServer Cache Statistics

Source: https://docs.rs/daedra/latest/daedra/server/struct.DaedraServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the current statistics of the server's cache, providing insights into its performance and usage.

```rust
pub fn cache_stats(&self) -> CacheStats
```

--------------------------------

### Check Skippable Href: Anchor Link

Source: https://docs.rs/daedra/latest/src/daedra/tools/crawl.rs.html

Tests `is_skippable_href` with a string starting with '#', indicating an anchor link, which should be considered skippable.

```rust
assert!(is_skippable_href("#section"));
```

--------------------------------

### Initialize FetchClient

Source: https://docs.rs/daedra/latest/src/daedra/tools/fetch.rs.html?search=

Creates a new FetchClient with a custom user agent, request timeout, and support for Gzip and Brotli compression. It also limits HTTP redirects.

```rust
pub fn new() -> DaedraResult<Self> {
        let client = Client::builder()
            .user_agent(USER_AGENT)
            .timeout(REQUEST_TIMEOUT)
            .gzip(true)
            .brotli(true)
            .redirect(reqwest::redirect::Policy::limited(10))
            .build()
            .map_err(DaedraError::HttpError)?;

        Ok(Self { client })
    }
```

--------------------------------

### SearchProvider Initialization with Backends

Source: https://docs.rs/daedra/latest/src/daedra/tools/backend.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a SearchProvider with a predefined list of search backends. This is used internally by the `new` and `auto` constructors.

```rust
fn from_backends(backends: Vec<Box<dyn SearchBackend>>) -> Self {
    let circuit_breakers = Self::init_circuit_breakers(&backends);
    Self {
        backends,
        rate_limiter: Self::new_rate_limiter(),
        backend_limiters: Self::new_backend_limiters(),
        backend_rate_limits: BackendRateLimiters::new(),
        circuit_breakers,
    }
}
```

--------------------------------

### Run DaedraServer with Transport

Source: https://docs.rs/daedra/latest/daedra/server/struct.DaedraServer.html?search=

Starts the Daedra server, listening for connections using the specified transport mechanism. This is an asynchronous operation.

```rust
pub async fn run(self, transport: TransportType) -> DaedraResult<()>
```

--------------------------------

### SearchProvider::new

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html?search=

Creates a new SearchProvider with a specified list of backends in priority order.

```APIDOC
## SearchProvider::new

### Description
Creates a new provider with the given backends (in priority order).

### Method
`new`

### Parameters
* `backends` (Vec<Box<dyn SearchBackend>>) - The list of search backends to use, ordered by priority.
```

--------------------------------

### Unsafe Undefined Behavior Example

Source: https://docs.rs/daedra/latest/daedra/types/type.DaedraResult.html

Demonstrates the unsafe nature of `unwrap_unchecked`. Calling this method on an `Err` value leads to undefined behavior.

```Rust
let x: Result<u32, &str> = Err("emergency failure");
unsafe { x.unwrap_unchecked() }; // Undefined behavior!
```

--------------------------------

### SearchBackend Trait Methods

Source: https://docs.rs/daedra/latest/src/daedra/tools/backend.rs.html?search=u32+-%3E+bool

Defines essential methods for any search backend, including getting its name and checking API key requirements.

```Rust
fn name(&self) -> &str;

    /// Whether this backend requires an API key.
    fn requires_api_key(&self) -> bool {
        false
    }

    /// Whether this backend is available (has required config/keys).
    fn is_available(&self) -> bool {
        true
    }
```

--------------------------------

### Create New SerperBackend Instance

Source: https://docs.rs/daedra/latest/daedra/tools/serper/struct.SerperBackend.html

Constructs a new Serper backend instance, requiring an API key for authentication.

```rust
pub fn new(api_key: String) -> Self
```

--------------------------------

### Get Server Information

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html

Retrieves essential server information, including protocol version, supported capabilities, and server name and version.

```APIDOC
## GET /server/info

### Description
Retrieves server initialization information.

### Method
GET

### Endpoint
/server/info

### Response
#### Success Response (200)
- **protocolVersion** (string) - The current protocol version.
- **capabilities** (object) - An object detailing server capabilities.
  - **tools** (object) - An object detailing available tools.
- **serverInfo** (object) - An object containing server metadata.
  - **name** (string) - The name of the server.
  - **version** (string) - The version of the server.

### Response Example
{
  "protocolVersion": "1.0",
  "capabilities": {
    "tools": {}
  },
  "serverInfo": {
    "name": "Daedra",
    "version": "0.1.0"
  }
}
```

--------------------------------

### SearchProvider::new

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html

Creates a new SearchProvider instance with a specified order of search backends.

```APIDOC
## `SearchProvider::new`

### Description
Create a new provider with the given backends (in priority order).

### Signature
`pub fn new(backends: Vec<Box<dyn SearchBackend>>) -> Self`

### Parameters
* `backends` - A vector of boxed dynamic `SearchBackend` trait objects, defining the priority order of backends.
```

--------------------------------

### Get Cached Search Response

Source: https://docs.rs/daedra/latest/src/daedra/cache.rs.html?search=

Retrieves a search response from the cache if it exists and caching is enabled. Logs a cache hit if successful.

```rust
pub async fn get_search(
    &self,
    query: &str,
    region: &str,
    safe_search: &str,
) -> Option<SearchResponse> {
    if !self.enabled {
        return None;
    }

    let key = Self::search_key(query, region, safe_search);
    let result = self.search_cache.get(&key).await;

    if result.is_some() {
        debug!(query = %query, "Cache hit for search query");
    }

    result
}
```

--------------------------------

### SearchProvider::new

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html?search=u32+-%3E+bool

Creates a new SearchProvider instance with a given vector of backends, ordered by priority.

```APIDOC
## SearchProvider::new

### Description
Creates a new provider with the given backends (in priority order).

### Method

```
pub fn new(backends: Vec<Box<dyn SearchBackend>>) -> Self
```

### Parameters

* `backends` (Vec<Box<dyn SearchBackend>>) - Required - A vector of boxed search backends, defining the priority order.
```

--------------------------------

### Run Server

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html

Starts the Daedra MCP server using the specified transport type. This is the primary method for initiating server operations.

```APIDOC
## run

### Description
Starts the Daedra MCP server with the specified transport type (STDIO or SSE).

### Method
`pub async fn run(self, transport: TransportType) -> DaedraResult<()>`

### Parameters
* `transport` (TransportType) - The type of transport to use for the server (e.g., `TransportType::Stdio`, `TransportType::Sse {{ port, host }}`).

### Returns
* `DaedraResult<()>` - An empty result indicating success or an error if the server fails to start.
```

--------------------------------

### List Available Backends

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html?search=u32+-%3E+bool

Returns a vector of strings, where each string is the name of an available backend that the SearchProvider can utilize.

```rust
pub fn available_backends(&self) -> Vec<&str>
```

--------------------------------

### Test Auto Provider with Backends

Source: https://docs.rs/daedra/latest/src/daedra/tools/backend.rs.html

Verifies that the `SearchProvider::auto()` constructor correctly initializes and reports a minimum number of available backends, including specific known ones.

```rust
    #[test]
    fn test_auto_has_backends() {
        let provider = SearchProvider::auto();
        let backends = provider.available_backends();
        // Should always have at least 7 no-key backends
        assert!(
            backends.len() >= 7,
            "Expected at least 7 backends, got {}",
            backends.len()
        );
        assert!(backends.contains(&"bing"));
        assert!(backends.contains(&"wikipedia"));
        assert!(backends.contains(&"stackoverflow"));
        assert!(backends.contains(&"github"));
        assert!(backends.contains(&"wiby"));
        assert!(backends.contains(&"ddg-instant"));
        assert!(backends.contains(&"duckduckgo"));
    }

```

--------------------------------

### Get Server Cache Statistics

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `cache_stats` function retrieves statistics about the server's cache. This is useful for monitoring cache performance and usage.

```rust
pub fn cache_stats(&self) -> crate::cache::CacheStats {
        self.handler.cache.stats()
    }
```

--------------------------------

### FetchClient::new() - Create a new fetch client

Source: https://docs.rs/daedra/latest/src/daedra/tools/fetch.rs.html?search=u32+-%3E+bool

Initializes a new FetchClient with a configured reqwest::Client. It sets a user agent, request timeout, and enables gzip and brotli compression. Redirects are limited to 10 hops.

```rust
/// HTTP client for fetching pages
#[derive(Clone)]
pub struct FetchClient {
    client: Client,
}

impl FetchClient {
    /// Create a new fetch client
    pub fn new() -> DaedraResult<Self> {
        let client = Client::builder()
            .user_agent(USER_AGENT)
            .timeout(REQUEST_TIMEOUT)
            .gzip(true)
            .brotli(true)
            .redirect(reqwest::redirect::Policy::limited(10))
            .build()
            .map_err(DaedraError::HttpError)?;

        Ok(Self { client })
    }
// ... other methods
```

--------------------------------

### Error::description Method Implementation (Deprecated)

Source: https://docs.rs/daedra/latest/daedra/types/enum.DaedraError.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Deprecated method for getting a string description of the error. Use the Display impl or to_string() instead.

```rust
fn description(&self) -> &str {
    // Implementation details omitted for brevity
}
```

--------------------------------

### Default FetchClient Implementation

Source: https://docs.rs/daedra/latest/src/daedra/tools/fetch.rs.html?search=

Provides a default implementation for FetchClient, creating a new instance. Expects the client creation to succeed, otherwise it panics.

```rust
impl Default for FetchClient {
    fn default() -> Self {
        Self::new().expect("Failed to create default fetch client")
    }
}
```

--------------------------------

### Get Crawl Arguments Schema

Source: https://docs.rs/daedra/latest/daedra/types/fn.crawl_args_schema.html

Returns the JSON Schema for the crawl_site tool arguments. This function is useful for validating inputs to the crawl_site tool.

```rust
pub fn crawl_args_schema() -> Value
```

--------------------------------

### Create Search Cache with Defaults

Source: https://docs.rs/daedra/latest/daedra/cache/struct.SearchCache.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a search cache instance using default configuration settings.

```rust
pub fn with_defaults() -> Self
```

--------------------------------

### Create New BingBackend Instance

Source: https://docs.rs/daedra/latest/daedra/tools/bing/struct.BingBackend.html?search=u32+-%3E+bool

Constructs a new instance of the Bing backend. This is the entry point for using the Bing scraping functionality.

```rust
pub fn new() -> Self
```

--------------------------------

### Test Skipping Internal Links

Source: https://docs.rs/daedra/latest/src/daedra/tools/bing.rs.html

Ensures that `parse_results` correctly filters out internal links (starting with '/') and only returns valid external URLs.

```rust
fn test_skip_internal() {
        let html = r"<li class=\"b_algo\"><h2><a href=\"/internal\">X</a></h2></li><li class=\"b_algo\"><h2><a href=\"https://real.com\">Y</a></h2></li>";
        let b = BingBackend::new();
        let r = b.parse_results(html, 10);
        assert_eq!(r.len(), 1);
        assert_eq!(r[0].url, "https://real.com");
    }
```

--------------------------------

### StackExchangeBackend::new

Source: https://docs.rs/daedra/latest/daedra/tools/stackexchange/struct.StackExchangeBackend.html?search=u32+-%3E+bool

Creates a new instance of the StackExchangeBackend. This is the entry point for interacting with the StackExchange API.

```APIDOC
## StackExchangeBackend::new

### Description
Create a new StackExchange backend instance.

### Method
`new()`

### Returns
- `Self`: A new instance of StackExchangeBackend.
```

--------------------------------

### Run DaedraServer with Transport

Source: https://docs.rs/daedra/latest/daedra/server/struct.DaedraServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the Daedra server, listening for connections using the specified TransportType. Returns a DaeraResult upon completion or error.

```rust
pub async fn run(self, transport: TransportType) -> DaeraResult<()>
```

--------------------------------

### Run Daedra Server as a Library

Source: https://docs.rs/daedra/latest/daedra/index.html?search=

Demonstrates how to initialize and run the Daedra server using the Stdio transport type when used as a library.

```rust
use daedra::{DaedraServer, ServerConfig, TransportType};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = ServerConfig::default();
    let server = DaedraServer::new(config)?;
    server.run(TransportType::Stdio).await?;
    Ok(())
}
```

--------------------------------

### Collecting Results into a Vector with Checked Addition

Source: https://docs.rs/daedra/latest/daedra/types/type.DaedraResult.html?search=std%3A%3Avec

Collects results from an iterator into a Result<Vec<u32>, &str>. This example demonstrates checking for overflow during addition.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

--------------------------------

### Collecting Results with FromIterator (Underflow Error)

Source: https://docs.rs/daedra/latest/daedra/types/type.DaedraResult.html?search=

Collects results from an iterator, returning the first Err encountered. This example shows an underflow error during subtraction.

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| 
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

--------------------------------

### List Available Tools

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides a list of available McpTool structures, each with a name, description, and input schema. Includes tools for web search, DuckDuckGo search, visiting pages, and crawling sites.

```rust
pub fn list_tools(&self) -> Vec<McpTool> {
        vec![
            McpTool {
                name: "web_search".to_string(),
                description: Some(
                    "Search the web using 9 backends (Wikipedia, StackOverflow, GitHub, Wiby, Bing, Serper, Tavily, DDG Instant, DDG). Returns aggregated results from multiple sources."
                        .to_string(),
                ),
                input_schema: search_args_schema(),
            },
            McpTool {
                name: "search_duckduckgo".to_string(),
                description: Some(
                    "Alias for web_search (backward compatibility). Search the web using 9 backends (Wikipedia, StackOverflow, GitHub, Wiby, Bing, Serper, Tavily, DDG Instant, DDG). Returns aggregated results from multiple sources."
                        .to_string(),
                ),
                input_schema: search_args_schema(),
            },
            McpTool {
                name: "visit_page".to_string(),
                description: Some(
                    "Visit a webpage and extract its content as Markdown. Useful for reading articles, documentation, or any web page."
                        .to_string(),
                ),
                input_schema: visit_page_args_schema(),
            },
            McpTool {
                name: "crawl_site".to_string(),
                description: Some(
                    "Crawl a website starting from a root URL. Discovers pages via sitemap.xml or link following, fetches up to max_pages concurrently, and returns Markdown content for each page."
                        .to_string(),
                ),
                input_schema: crawl_args_schema(),
            },
        ]
    }
```

--------------------------------

### StackExchangeBackend::new

Source: https://docs.rs/daedra/latest/daedra/tools/stackexchange/struct.StackExchangeBackend.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of the StackExchangeBackend. This is the entry point for using the StackExchange search functionality.

```APIDOC
## StackExchangeBackend::new

### Description
Creates a new StackExchange backend instance.

### Method
`new()`

### Returns
- `Self`: A new instance of `StackExchangeBackend`.
```

--------------------------------

### Collecting Results with FromIterator (Success)

Source: https://docs.rs/daedra/latest/daedra/types/type.DaedraResult.html?search=

Collects results from an iterator, returning a container of values if all elements are Ok. This example demonstrates successful addition of integers.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| 
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

--------------------------------

### FetchClient::new

Source: https://docs.rs/daedra/latest/src/daedra/tools/fetch.rs.html?search=std%3A%3Avec

Creates a new FetchClient with a configured HTTP client. It sets a user agent, request timeout, and enables gzip and brotli compression. Redirects are limited to 10.

```rust
/// HTTP client for fetching pages
#[derive(Clone)]
pub struct FetchClient {
    client: Client,
}

impl FetchClient {
    /// Create a new fetch client
    pub fn new() -> DaedraResult<Self> {
        let client = Client::builder()
            .user_agent(USER_AGENT)
            .timeout(REQUEST_TIMEOUT)
            .gzip(true)
            .brotli(true)
            .redirect(reqwest::redirect::Policy::limited(10))
            .build()
            .map_err(DaedraError::HttpError)?;

        Ok(Self { client })
    }

```

--------------------------------

### Create Auto-Detected SearchProvider

Source: https://docs.rs/daedra/latest/daedra/tools/backend/struct.SearchProvider.html?search=

Creates a SearchProvider instance that automatically detects and includes all available search backends from the environment.

```rust
pub fn auto() -> Self>
```

--------------------------------

### Get Cached Page Content

Source: https://docs.rs/daedra/latest/src/daedra/cache.rs.html?search=

Retrieves page content from the cache if available and caching is enabled. Logs a cache hit upon successful retrieval.

```rust
pub async fn get_page(&self, url: &str, selector: Option<&str>) -> Option<PageContent> {
    if !self.enabled {
        return None;
    }

    let key = Self::page_key(url, selector);
    let result = self.page_cache.get(&key).await;

    if result.is_some() {
        debug!(url = %url, "Cache hit for page content");
    }

    result
}
```

--------------------------------

### Server Initialization

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=

Initializes the Daedra server with a fetch client and an initialized flag.

```rust
fetch_client: Arc::new(fetch::FetchClient::new()?),
            initialized: Arc::new(RwLock::new(false)),
```

--------------------------------

### Initialize and Get Pointer

Source: https://docs.rs/daedra/latest/daedra/tools/wikipedia/struct.WikipediaBackend.html?search=u32+-%3E+bool

Initializes a type with a given initializer and returns its pointer. Also provides methods for dereferencing and dropping. Part of the `Pointable` trait.

```rust
const ALIGN: usize

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)
```

--------------------------------

### Get Cached Page Content

Source: https://docs.rs/daedra/latest/daedra/cache/struct.SearchCache.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves cached page content for a given URL and optional selector. Returns None if no cached content is found.

```rust
pub async fn get_page( &self, url: &str, selector: Option<&str>, ) -> Option<PageContent>
```

--------------------------------

### GitHubBackend::new

Source: https://docs.rs/daedra/latest/daedra/tools/github/struct.GitHubBackend.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of the GitHub search backend.

```APIDOC
## GitHubBackend::new

### Description
Creates a new GitHub search backend instance.

### Method
`new()`

### Returns
- `Self`: A new GitHubBackend instance.
```

--------------------------------

### Test: Auto Provider Has Backends

Source: https://docs.rs/daedra/latest/src/daedra/tools/backend.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Verifies that the `SearchProvider::auto()` constructor initializes with a minimum number of expected backends.

```rust
    #[test]
    fn test_auto_has_backends() {
        let provider = SearchProvider::auto();
        let backends = provider.available_backends();
        // Should always have at least 7 no-key backends
        assert!(
            backends.len() >= 7,
            "Expected at least 7 backends, got {}",
            backends.len()
        );
        assert!(backends.contains(&"bing"));
        assert!(backends.contains(&"wikipedia"));
        assert!(backends.contains(&"stackoverflow"));
        assert!(backends.contains(&"github"));
        assert!(backends.contains(&"wiby"));
        assert!(backends.contains(&"ddg-instant"));
        assert!(backends.contains(&"duckduckgo"));
    }
```

--------------------------------

### Check if MIME Type is Binary

Source: https://docs.rs/daedra/latest/src/daedra/tools/fetch.rs.html?search=

Checks if a MIME type is considered binary. This includes known binary types, PDFs, and types starting with 'application/vnd.'.

```rust
fn is_binary_mime(mime: &str) -> bool {
    is_known_binary_content_type(mime)
        || mime == "application/pdf"
        || mime.starts_with("application/vnd.")
}
```

--------------------------------

### BingBackend::new

Source: https://docs.rs/daedra/latest/daedra/tools/bing/struct.BingBackend.html?search=u32+-%3E+bool

Creates a new instance of the BingBackend. This is the entry point for using the Bing search functionality.

```APIDOC
## BingBackend::new

### Description
Creates a new Bing backend instance.

### Method
`new()`

### Returns
- `Self`: A new instance of BingBackend.
```

--------------------------------

### Resolve Absolute URL - JavaScript Scheme

Source: https://docs.rs/daedra/latest/src/daedra/tools/crawl.rs.html

Attempts to resolve a URL starting with 'javascript:'. This is considered an invalid scheme for web crawling and should return None.

```rust
let base = Url::parse("https://example.com").unwrap();
        assert!(resolve_absolute_url(&base, "javascript:alert(1)").is_none());
```

--------------------------------

### Run Server with Transport Type

Source: https://docs.rs/daedra/latest/src/daedra/server.rs.html?search=

Starts the Daedra MCP server using the specified transport type. This is the main entry point for running the server.

```APIDOC
## POST /run

### Description
Starts the Daedra MCP server with a specified transport type.

### Method
POST

### Endpoint
/run

### Request Body
- **transport** (TransportType) - Required - The type of transport to use (Stdio or Sse).

### Response
#### Success Response (200)
- **()** - Indicates successful server startup.

#### Response Example
(No specific response body for success, indicates completion of startup process)
```
Tokens:
Raw