Connect an AI editor to your nestrs project

use nestrs_mcp::tools::introspection::IntrospectionTools;
use rmcp::service::serve_server;
use rmcp::transport::stdio;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let running = serve_server(IntrospectionTools, stdio())
        .await
        .map_err(|e| std::io::Error::other(format!("stdio init: {e}")))?;
    running
        .waiting()
        .await
        .map_err(|e| std::io::Error::other(format!("stdio run: {e}")))?;
    Ok(())
}

[dependencies]
nestrs-mcp = "1.5.0"
# rmcp is not re-exported — depend on it directly with the server +
# transport features (transport-io = stdio; add transport-streamable-http-server for HTTP).
rmcp = { version = "3.1", default-features = false, features = ["server", "transport-io"] }
tokio = { version = "1", features = ["full"] }

nestrs-mcp --transport http --http-addr 127.0.0.1:7777

curl -sS -X POST http://127.0.0.1:7777/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"smoke","version":"0.0.1"}}}'

nestrs = { path = "../nestrs", features = ["admin"] }

use nestrs::admin::AdminOptions;

let app = NestFactory::create::<AppModule>().enable_health_check("/live");
let admin = app.use_admin(AdminOptions {
    addr: "127.0.0.1:7777".parse()?,
    token: Some(std::env::var("NESTRS_ADMIN_TOKEN")?),
});
tokio::spawn(async move { let _ = admin.serve().await; });

use nestrs_mcp::{user_text, CacheHints, McpSurfaces};
use rmcp::model::{CacheScope, PromptArgument, Resource, ResourceContents, ResourceTemplate};

let surfaces = McpSurfaces::new()
    // prompts/list + prompts/get: the handler receives the client's
    // argument map and returns the prompt messages.
    .register_prompt(
        "review",
        Some("Code review prompt".into()),
        vec![PromptArgument::new("topic").with_required(true)],
        |args| Ok(vec![user_text("Review this code")]),
    )
    // resources/list + resources/read
    .register_resource(
        Resource::new("nestrs://health", "health").with_mime_type("text/plain"),
        |uri| Ok(vec![ResourceContents::text("ok", uri)]),
    )
    // Resource templates: the client expands the RFC 6570 template
    // itself, then calls resources/read on the resulting URI.
    .register_resource_template(
        ResourceTemplate::new("nestrs://docs/{name}", "doc_tmpl"),
        |uri| Ok(vec![ResourceContents::text("doc body", uri)]),
    )
    // completion/complete — one handler; it reads the request's `ref`
    // to tell which prompt/resource argument is being completed.
    .register_complete(|partial, _req| Ok(vec![format!("{partial}-alpha")]))
    // Mark a URI as eligible for subscription (SEP-1696). Only then is
    // `resources.subscribe` advertised in `initialize`.
    .register_subscribable_resource("nestrs://health")
    // SEP-2549 cache hints on every list/read result (protocol >= 2026-07-28 only).
    .with_cache_hints(CacheHints::new(60_000, CacheScope::Public));

let server = nestrs_mcp::server::NestrsMcpServer::new().with_surfaces(surfaces);

use nestrs_mcp::{elicit_input, input_responses};
use rmcp::model::{CallToolRequestParams, ElicitationSchema, PrimitiveSchemaDefinition, StringSchema};
use std::collections::BTreeMap;

// First round — return this from the tool body:
let mut props = BTreeMap::new();
props.insert(
    "colour".to_string(),
    PrimitiveSchemaDefinition::String(
        StringSchema::new()
            .title("Colour")
            .description("Pick one"),
    ),
);
let result = elicit_input("Pick a colour", ElicitationSchema::new(props), None);

// Retry round — the client answered under the same key:
if let Some(responses) = input_responses(&request) {
    let colour = responses.get("input"); // the ElicitResult JSON
}
// (`request` is the rmcp CallToolRequestParams for the retried call.)

use nestrs_mcp::server::NestrsMcpServer;
use nestrs_mcp::McpSurfaces;

let surfaces = McpSurfaces::new().register_elicitation(|request, context| {
    // Forward `request` to the client (e.g. via context.peer) or to
    // another service; return the client's ElicitResult
    // (Accept / Decline / Cancel) or an error string.
    todo!()
});

let server = NestrsMcpServer::new().with_surfaces(surfaces);
// later, inside a tool body:
// let answer = server.elicit(elicit_request_params, context).await?;

use nestrs_mcp::server::NestrsMcpServer;
use rmcp::model::{CallToolResult, ContentBlock, CreateTaskResult};
use rmcp::task_manager::TaskOptions;

let server = NestrsMcpServer::new().with_task_support();

// Inside a tool body — the future must be 'static (move owned data in):
let task = server.spawn_task(TaskOptions::default(), |ctx| {
    Box::pin(async move {
        // Cooperative cancellation + mid-flight input, both on `ctx`:
        //   tokio::select! { _ = ctx.cancelled() => Err(TaskExit::Cancelled), ... }
        //   let answer = ctx.request_input("input", request).await?;
        Ok(CallToolResult::success(vec![ContentBlock::text("done")]))
    })
});
// Return `CallToolResponse::Task(CreateTaskResult::new(task))` from the tool;
// the client then drives it with tasks/get.

nestrs-mcp = { version = "1.5.0", features = ["authz"] }

use nestrs_mcp::server::NestrsMcpServer;
use nestrs_mcp::McpDataContext;

let ctx = McpDataContext::new()
    .with_ability(ability)     // Arc<nestrs::Ability> — CASL-style rules
    .with_principal(principal) // Arc<nestrs::policies::Principal> — row-level predicates
    .with_pool(pool);          // Arc<sqlx::AnyPool> — per-tool-call transactions

let server = NestrsMcpServer::new().with_data_context(ctx);