Struct AgentClient 

pub struct AgentClient { /* private fields */ }

Client for Wauldo MCP Server

Example

use wauldo::{AgentClient, ReasoningOptions};

#[tokio::main]
async fn main() -> wauldo::Result<()> {
    let mut client = AgentClient::new().connect().await?;

    let result = client.reason("How to optimize?").await?;
    println!("{}", result.solution);

    client.disconnect().await;
    Ok(())
}

Implementations

impl AgentClient

pub async fn chunk_document( &mut self, content: &str, chunk_size: usize, ) -> Result<ChunkResult>

Chunk a document

pub async fn retrieve_context( &mut self, query: &str, top_k: usize, ) -> Result<RetrievalResult>

Retrieve context for a query

pub async fn summarize(&mut self, content: &str) -> Result<String>

Summarize content

impl AgentClient

pub async fn extract_concepts( &mut self, text: &str, source_type: SourceType, ) -> Result<ConceptResult>

Extract concepts from text or code

impl AgentClient

pub async fn search_knowledge( &mut self, query: &str, limit: usize, ) -> Result<KnowledgeGraphResult>

Search knowledge graph

pub async fn add_to_knowledge( &mut self, text: &str, ) -> Result<KnowledgeGraphResult>

Add to knowledge graph

pub async fn knowledge_stats(&mut self) -> Result<KnowledgeGraphResult>

Get knowledge graph stats

impl AgentClient

pub async fn plan_task(&mut self, task: &str) -> Result<PlanResult>

Plan a task

pub async fn plan_task_with_options( &mut self, task: &str, options: PlanOptions, ) -> Result<PlanResult>

Plan a task with options

impl AgentClient

pub async fn reason(&mut self, problem: &str) -> Result<ReasoningResult>

Perform Tree-of-Thought reasoning

Example

let mut client = AgentClient::new().connect().await?;
let result = client
    .reason_with_options(
        "What's the best sorting algorithm?",
        ReasoningOptions::new().depth(4).branches(3)
    )
    .await?;

pub async fn reason_with_options( &mut self, problem: &str, options: ReasoningOptions, ) -> Result<ReasoningResult>

Perform reasoning with custom options

impl AgentClient

pub fn new() -> Self

Create a new client with default options

pub fn with_options(options: ClientOptions) -> Self

Create a new client with custom options

pub async fn connect(self) -> Result<Self>

Connect to MCP server

pub async fn disconnect(&mut self)

Disconnect from MCP server

pub async fn list_tools(&mut self) -> Result<Vec<ToolDefinition>>

List available tools

pub async fn call_tool( &mut self, name: &str, arguments: Value, ) -> Result<String>

Call a tool by name

Trait Implementations

impl Default for AgentClient

Creates a disconnected client with default options. Call .connect().await? before using MCP methods.

fn default() -> Self

Returns the “default value” for a type.