techne 0.1.0-dev.2

A simple MCP implementation for Rust
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

<div align="center">

# Techne

[![Documentation](https://docs.rs/techne/badge.svg)](https://docs.rs/techne)
[![Crates.io](https://img.shields.io/crates/v/techne.svg)](https://crates.io/crates/techne)
[![License](https://img.shields.io/crates/l/techne.svg)](https://github.com/hecrj/techne/blob/master/LICENSE)
[![Downloads](https://img.shields.io/crates/d/techne.svg)](https://crates.io/crates/techne)
[![Test Status](https://img.shields.io/github/actions/workflow/status/hecrj/techne/test.yml?branch=master&event=push&label=test)](https://github.com/hecrj/techne/actions)

An MCP implementation for Rust focused on simplicity and type-safety.
</div>

## Features

- Completely handmade!
- No macros!
- Coherent schemas enforced at the type level
- Stdio and Streamable HTTP transports
- Custom transports
- Latest protocol version (`2025-06-18`)

**Very experimental! Only the `tools` capability is currently supported.**

## Server
Create a `Server`, choose your desired transport, list your tools, and run:

```rust
use techne::Server;
use techne::server::Stdio;
use techne::server::tool::{tool, string};

use std::io;

#[tokio::main]
pub async fn main() -> io::Result<()> {
    let server = Server::new("techne-server-example", env!("CARGO_PKG_VERSION"));
    let transport = Stdio::current();

    let tools = [
        tool(say_hello, string("name", "The name to say hello to"))
            .name("say_hello")
            .description("Say hello to someone"),
    ];

    server.tools(tools).run(transport).await
}

async fn say_hello(name: String) -> String {
    format!("Hello, {name}!")
}
```

## Client
Create a `Client` with your desired transport and query the server:

```rust
use techne::Client;
use techne::client::Stdio;
use techne::mcp::json;

use std::io;

#[tokio::main]
pub async fn main() -> io::Result<()> {
    let transport = Stdio::run("cargo", ["run", "--example", "server"])?;

    let mut client = Client::new(
        "techne-client-example",
        env!("CARGO_PKG_VERSION"),
        transport,
    )
    .await?;

    let tools = client.list_tools().await?;

    let hello = client
        .call_tool("say_hello", json!({ "name": "World" }))
        .await?;

    dbg!(tools);
    dbg!(hello);

    Ok(())
}
```