agentix 0.22.1

Multi-provider LLM client for Rust — streaming, non-streaming, tool calls, MCP, DeepSeek, OpenAI, Anthropic, Gemini, Mimo
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

#[cfg(feature = "mcp")]
mod mcp_example {
    use agentix::{LlmEvent, McpTool, Provider, Request, Tool, ToolBundle};
    use futures::StreamExt;
    use std::env;
    use std::time::Duration;

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        // We'll use Anthropic for this example, as Claude is excellent with tools.
        let api_key = env::var("ANTHROPIC_API_KEY")
            .expect("ANTHROPIC_API_KEY must be set in your environment variables");

        let http = reqwest::Client::new();

        println!("Starting MCP server (this might take a few seconds)...");

        // Connect to an MCP server via stdio.
        // Here we use the official Memory MCP server via NPX as an example.
        // (Requires Node.js/npx to be installed on your system).
        let mcp_tool = McpTool::stdio("npx", &["-y", "@modelcontextprotocol/server-memory"])
            .await?
            .with_timeout(Duration::from_secs(30));

        // Group the MCP tools into a ToolBundle
        // (A single MCP server can expose multiple tools)
        let mut bundle = ToolBundle::new();
        bundle.push(mcp_tool);

        println!("MCP server connected. Exposed tools:");
        for tool in bundle.raw_tools() {
            println!(" - {}", tool.function.name);
        }

        println!("\nSending request to Claude...");

        // Create the request and attach the MCP tool definitions
        let mut stream = Request::new(Provider::Anthropic, api_key)
            .system_prompt("You are a helpful AI assistant. You have access to a memory tool.")
            .user("Save the secret phrase 'RUST-IS-AWESOME' to memory, and then verify it by reading it back.")
            .tools(bundle.raw_tools())
            .stream(&http)
            .await?;

        println!("\nResponse stream:");

        while let Some(event) = stream.next().await {
            match event {
                LlmEvent::Token(t) => {
                    print!("{t}");
                }
                LlmEvent::ToolCall(tc) => {
                    println!("\n\n[Model is calling MCP tool: {}]", tc.name);
                    println!("Arguments: {}", tc.arguments);

                    // In a fully autonomous loop, you would execute the tool call
                    // and return the result back to the model as a new message.
                }
                LlmEvent::Done => break,
                LlmEvent::Error(e) => eprintln!("\nError: {e}"),
                _ => {}
            }
        }

        println!("\n");

        Ok(())
    }
}

#[cfg(feature = "mcp")]
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    mcp_example::run().await
}

// Dummy main for when the feature is disabled
#[cfg(not(feature = "mcp"))]
fn main() {
    println!("Please run this example with the `mcp` feature enabled:");
    println!("cargo run --example 05_mcp_client --features mcp");
}