模型上下文协议SDK

let store = Task_store.create () in
let server =
  Server.create ~name:"my-server" ~version:"1.0.0" ()
  |> Server.add_task_handlers (Task_store.to_task_handlers store)
in
(* In a tool handler: create a task, do work, update status *)
let task = Task_store.create_task store () in
(* ... run work in a fiber ... *)
Task_store.update_status store task.task_id Completed
  ~updated_at:(string_of_float (Unix.gettimeofday ())) |> ignore

(* Stdio *)
module Stdio_server = Mcp_protocol_eio.Generic_server.Make(Stdio_transport)

(* In-memory for tests *)
module Test_server = Mcp_protocol_eio.Generic_server.Make(Memory_transport)

(* With logging middleware *)
module Logged = Mcp_protocol_eio.Middleware.Logging(Stdio_transport)
module Debug_server = Mcp_protocol_eio.Generic_server.Make(Logged)

let handler _ctx _name args =
  let open Tool_arg in
  let* text = required args "text" string in
  let count = optional args "count" int ~default:1 in
  Ok (Mcp_types.tool_result_of_text (String.concat "" (List.init count (fun _ -> text))))

opam pin add mcp_protocol git+https://github.com/jeong-sik/mcp-protocol-sdk.git

(depends
 (mcp_protocol (>= 1.3.0)))

(libraries mcp_protocol mcp_protocol.eio mcp_protocol.http)

let server =
  Server.create ~name:"my-server" ~version:"1.0" ()
  |> Server.tool "echo" ~description:"Echo input"
       (fun _ctx _name args ->
         let open Tool_arg in
         let* text = required args "text" string in
         Ok (Mcp_types.tool_result_of_text text))
  |> Server.resource ~uri:"mcp://info" "info" ~mime_type:"application/json"
       (fun _ctx _uri ->
         Ok [Mcp_types.{ uri = "mcp://info"; mime_type = Some "application/json";
                         text = Some {|{"status":"ok"}|}; blob = None }])
  |> Server.prompt "greet" ~description:"Greeting"
       (fun _ctx _name args ->
         let who = match List.assoc_opt "name" args with Some n -> n | None -> "world" in
         Ok Mcp_types.{ description = None;
           messages = [{ role = User;
             content = PromptText { type_ = "text"; text = "Hello, " ^ who } }];
           _meta = None })

module Mt = Mcp_protocol_eio.Memory_transport
module Test_server = Mcp_protocol_eio.Generic_server.Make(Mt)
module Test_client = Mcp_protocol_eio.Generic_client.Make(Mt)

let () =
  Eio_main.run @@ fun env ->
  Eio.Switch.run @@ fun sw ->
  let client_t, server_t = Mt.create_pair () in
  let server = Test_server.create ~name:"test" ~version:"1.0" ()
    |> Test_server.tool "ping" (fun _ _ _ -> Ok (Mcp_types.tool_result_of_text "pong"))
  in
  Eio.Fiber.fork ~sw (fun () ->
    Test_server.run server ~transport:server_t ~clock:(Eio.Stdenv.clock env) ());
  let client = Test_client.create ~transport:client_t ~clock:(Eio.Stdenv.clock env) () in
  match Test_client.initialize client ~client_name:"test" ~client_version:"1.0" with
  | Ok _ -> ignore (Test_client.call_tool client ~name:"ping" ())
  | Error e -> Printf.eprintf "Failed: %s\n" e

let () =
  Eio_main.run @@ fun env ->
  Eio.Switch.run @@ fun sw ->
  let server =
    Http_server.create ~name:"my-server" ~version:"1.0.0" ()
    |> Http_server.add_tool
         (Mcp_types.make_tool ~name:"echo" ~description:"Echo" ())
         (fun _ctx _name args ->
           let open Tool_arg in
           let* text = required args "text" string in
           Ok (Mcp_types.tool_result_of_text ("Echo: " ^ text)))
  in
  let net = Eio.Stdenv.net env in
  let addr = `Tcp (Eio.Net.Ipaddr.V4.loopback, 8080) in
  let socket = Eio.Net.listen ~sw net addr ~backlog:128 in
  Cohttp_eio.Server.run socket
    (Cohttp_eio.Server.make
       ~callback:(Http_server.callback server) ())
    ~on_error:(fun exn -> Printf.eprintf "%s\n" (Printexc.to_string exn))

let () =
  Eio_main.run @@ fun env ->
  Eio.Switch.run @@ fun sw ->
  let net = Eio.Stdenv.net env in
  let client = Http_client.create ~endpoint:"http://127.0.0.1:8080/mcp" ~net ~sw () in
  match Http_client.initialize client ~client_name:"my-client" ~client_version:"1.0" with
  | Ok result ->
    Printf.printf "Connected to %s\n" result.server_info.name;
    ignore (Http_client.close client)
  | Error e -> Printf.eprintf "Failed: %s\n" e

let () =
  Eio_main.run @@ fun env ->
  Eio.Switch.run @@ fun sw ->
  let net = Eio.Stdenv.net env in
  match Oauth_client.discover ~net ~sw ~issuer:"https://auth.example.com" with
  | Error e -> Printf.eprintf "Discovery failed: %s\n" e
  | Ok metadata ->
    let verifier, challenge = Oauth_client.generate_pkce () in
    let state = Oauth_client.generate_state () in
    let auth_url = Oauth_client.build_authorization_url
      ~authorization_endpoint:metadata.authorization_endpoint
      ~client_id:"my-client" ~redirect_uri:"http://localhost:9999/callback"
      ~scopes:["read"] ~state ~code_challenge:challenge () in
    Printf.printf "Visit: %s\n" auth_url;
    ignore (Oauth_client.exchange_code ~net ~sw
      ~token_endpoint:metadata.token_endpoint
      ~client_id:"my-client" ~code:"AUTH_CODE"
      ~redirect_uri:"http://localhost:9999/callback"
      ~code_verifier:verifier)

(* JSON-RPC standard *)
Error_codes.parse_error        (* -32700 *)
Error_codes.invalid_request    (* -32600 *)
Error_codes.method_not_found   (* -32601 *)
Error_codes.invalid_params     (* -32602 *)
Error_codes.internal_error     (* -32603 *)

(* MCP-specific *)
Error_codes.connection_closed      (* -32001 *)
Error_codes.request_timeout        (* -32002 *)
Error_codes.resource_not_found     (* -32003 *)
Error_codes.tool_execution_error   (* -32004 *)

dune runtest
bash scripts/check-release-metadata.sh

bash scripts/run-conformance.sh

git clone https://github.com/jeong-sik/mcp-protocol-sdk.git
cd mcp-protocol-sdk
opam install . --deps-only
dune build