moonmcp

#Quick start

#mcp.tool(description="Add two numbers")
fn add(a : Double, b : Double) -> Double {
  a + b
}

#mcp.resource("config://app", mime_type="application/json")
fn config() -> String {
  "{\"theme\":\"dark\"}"
}

async fn main {
  let mcp = @moonmcp.Server::new("demo", version="1.0.0")
  register(mcp)
  @mooncat.serve(mcp.to_asgi(), port=12000) catch {
    e => println("stopped: \{e}")
  }
}

#Annotations

#mcp.tool(description="Add two numbers")
fn add(a : Double, b : Double) -> Double {
  a + b
}

#mcp.tool(name="word_count")
fn count(text : String, unique~ : Bool = false) -> Int {
  ...
}

#mcp.resource("users://{id}/profile")
fn profile(id : Int) -> String {
  "profile of user \{id}"
}

#mcp.prompt(description="Ask for a code review")
fn review(code : String, focus? : String) -> String {
  ...
}

rule(name: "mcp", command: "moonx moonbitstack/moonmcp/cmd/mcp@0.1.7 -C \"$mod_dir\" \"$input\" -o \"$output\"")

dev_build(rule: "mcp", input: "tools.mbt", output: "tools.g.mbt")
formatter(ignore: [ "tools.g.mbt" ])

#Registering by hand

async fn main {
  let mcp = @moonmcp.Server::new("demo", version="1.0.0")
  mcp.tool(
    "add",
    args => {
      guard args.get("a") is Some(Number(a, ..)) &&
        args.get("b") is Some(Number(b, ..)) else {
        fail("a and b must be numbers")
      }
      { "sum": Json(a + b) }
    },
    description="Add two numbers",
    input_schema={
      "type": "object",
      "properties": { "a": { "type": "number" }, "b": { "type": "number" } },
      "required": ["a", "b"],
    },
  )
  mcp.resource("config://app", () => "{\"theme\":\"dark\"}", mime_type="application/json")
  @mooncat.serve(mcp.to_asgi(), port=12000) catch {
    e => println("stopped: \{e}")
  }
}

#Request context

async fn main {
  let mcp = @moonmcp.Server::new("demo")
  mcp.tool_context(
    "summarise",
    async fn(args : Map[String, Json], context : @context.Context) {
      let tenant = context.header("x-tenant").unwrap_or("public")
      context.report_progress(progress=0.0, total=1.0, message="reading") catch {
        _ => ()
      }
      let text = match args.get("text") {
        Some(String(text)) => text
        _ => ""
      }
      context.report_progress(progress=1.0, total=1.0) catch { _ => () }
      @moonmcp.ToolResult::new(
        content=[@moonmcp.text_block("\{tenant}: \{text.length()} characters")],
      )
    },
  )
}

#Transports

#Progress and subscriptions

async fn main {
  let mcp = @moonmcp.Server::new("demo")
  mcp.tool_context("count", async fn(_args : Map[String, Json], context : @context.Context) {
    context.report_progress(progress=1.0, total=2.0, message="half way") catch {
      _ => ()
    }
    @moonmcp.ToolResult::new(content=[@moonmcp.text_block("done")])
  })
  @mooncat.serve(mcp.to_asgi(), port=12000) catch { _ => () }
}

async fn main {
  let mcp = @moonmcp.Server::new("demo")
  // ... register the tools ...
  mcp.notify_tools_changed()
  mcp.notify_resource_updated("config://app")
}

#Asking the client for input

async fn main {
  let mcp = @moonmcp.Server::new("demo")
  mcp.tool_context("greet", async fn(_args : Map[String, Json], context : @context.Context) {
    match context.input_responses().get("name") {
      Some(String(name)) =>
        @moonmcp.ToolResult::new(content=[@moonmcp.text_block("hello " + name)])
      _ =>
        @moonmcp.ToolResult::input_required({
          input_requests: [
            {
              id: "name",
              request: {
                "method": Json::string("elicitation/create"),
                "params": {
                  "message": Json::string("Your name?"),
                  "requestedSchema": { "type": "object" },
                },
              },
            },
          ],
          request_state: Some("greeting"),
          meta: None,
        })
    }
  })
}

#Client

async fn main {
  let mcp = @moonmcp.Server::new("demo")
  mcp.tool("add", args => {
    let a = match args.get("a") {
      Some(Number(value, ..)) => value
      _ => 0.0
    }
    { "sum": Json(a) }
  })
  let client = @moonmcp.Client::connect(
    @moonmcp.Memory::new(mcp),
    protocol_version="2026-07-28",
  )
  let tools = client.list_tools()
  println("\{tools.length()} tools")
  let result = client.call_tool("add", arguments={ "a": 2, "b": 3 })
  println(Json(result.structured_content.unwrap()).stringify())
  client.close()
}

let client = @client.Client::connect(@http.Http::new("http://127.0.0.1:12000/mcp"))

#Authorization

async fn main {
  let mcp = @moonmcp.Server::new("demo")
  let bearer = @moonmcp.Bearer::hmac(secret="s3cret")
  @mooncat.serve(mcp.to_asgi(auth=Some(bearer)), port=12000) catch {
    _ => ()
  }
}

async fn main {
  let mcp = @moonmcp.Server::new("demo")
  mcp.tool_context(
    "whoami",
    async fn(_args : Map[String, Json], context : @moonmcp.Context) {
      let subject = context.subject().unwrap_or("nobody")
      let role = match context.claims().get("role") {
        Some(String(role)) => role
        _ => "no role"
      }
      @moonmcp.ToolResult::new(content=[
        @moonmcp.text_block("\{subject} (\{role})"),
      ])
    },
  )
}

#Logging

async fn main {
  let sink = @moonlog.Lines::new(fn(line) { println(line) })
  let hub = @moonlog.Hub::new()
  let slot = @moonlog.Slot::new(sink, name="console").layout(
    @moonlog.Pattern::parse("{level} {target}: {msg}"),
  )
  ignore(hub.add(slot) catch {
    e => abort("the log hub refused the slot: " + e.to_text())
  })
  let mcp = @moonmcp.Server::new("demo")
  mcp.log_to(logger=hub.logger("moonmcp"))
}

#Debug page

@mooncat.serve(mcp.to_asgi(), port=12000)

#Connect a client

{
  "mcpServers": {
    "demo": {
      "command": "moon",
      "args": ["run", "src/examples/stdio", "--target", "native"]
    }
  }
}

{
  "mcpServers": {
    "demo": {
      "url": "http://127.0.0.1:12000/mcp",
      "transport": "streamable-http"
    }
  }
}

#Examples

#Packages

#Install

moon add moonbitstack/moonmcp

#Licence