para

#!/usr/bin/env raku
use v6.d;

use MCP::Server;
use MCP::Client;
use MCP::Types;
use MCP::Transport::Base;
use MONKEY-TYPING;
need MCP::JSONRPC;



head

advanced-client - In-process client/server loopback for advanced features


Creates a client and a server connected by an in-process loopback transport.
This keeps the example fully runnable without external services while still
demonstrating:


- Pagination through list endpoints
- Completions for prompts and resources
- Roots (server requesting roots from the client)
- Elicitation (server asking the client for input)


make run-example EXAMPLE=advanced-client



class LoopbackTransport does MCP::Transport::Base::Transport {
    has Supplier $!incoming = Supplier.new;
    has Bool $!connected = False;
    has LoopbackTransport $.peer is rw;
    has @!sent;

    method start(--> Supply) {
        $!connected = True;
        $!incoming.Supply;
    }

    method send(MCP::JSONRPC::Message $msg --> Promise) {
        @!sent.push($msg);
        $.peer!emit($msg) if $.peer.defined;
        Promise.kept(True);
    }

    method close(--> Promise) {
        $!connected = False;
        $!incoming.done;
        Promise.kept(True);
    }

    method is-connected(--> Bool) { $!connected }

    method !emit(MCP::JSONRPC::Message $msg) {
        $!incoming.emit($msg);
    }
}

sub loopback-pair(--> List) {
    my $a = LoopbackTransport.new;
    my $b = LoopbackTransport.new;
    $a.peer = $b;
    $b.peer = $a;
    ($a, $b)
}

augment class MCP::Server::Server {
    method handle-message-public($msg) { self!handle-message($msg) }
}

sub show-pagination(Client $client) {
    say "\n== Pagination ==";

    my %tools-page1 = await $client.list-tools;
    say "Tools page 1: " ~ %tools-page1<tools>.map(*.name).sort.join(', ');
    if %tools-page1<nextCursor>:exists {
        my %tools-page2 = await $client.list-tools(cursor => %tools-page1<nextCursor>);
        say "Tools page 2: " ~ %tools-page2<tools>.map(*.name).sort.join(', ');
    }

    my %prompts-page1 = await $client.list-prompts;
    say "Prompts page 1: " ~ %prompts-page1<prompts>.map(*.name).sort.join(', ');
    if %prompts-page1<nextCursor>:exists {
        my %prompts-page2 = await $client.list-prompts(cursor => %prompts-page1<nextCursor>);
        say "Prompts page 2: " ~ %prompts-page2<prompts>.map(*.name).sort.join(', ');
    }
}

sub show-completions(Client $client) {
    say "\n== Completions ==";

    my $prompt-result = await $client.complete-prompt(
        'code-review',
        argument-name => 'language',
        value => 'ru',
    );
    say "Prompt completion values: " ~ $prompt-result.values.join(', ');

    my $resource-result = await $client.complete-resource(
        'file:///projects',
        argument-name => 'path',
        value => 'pro',
    );
    say "Resource completion values: " ~ $resource-result.values.join(', ');
}

sub show-roots-and-elicitation(Server $server) {
    say "\n== Roots ==";
    my @roots = await $server.list-roots;
    say "Roots from client: " ~ @roots.map(*.uri).join(', ');

    say "\n== Elicitation ==";
    my $form-response = await $server.elicit(
        message => 'Who is approving this request?',
        schema => {
            type => 'object',
            properties => {
                name => { type => 'string' },
                approved => { type => 'boolean' },
            },
            required => ['name', 'approved'],
        },
    );
    say "Form elicitation action: {$form-response.action}";
    say "Form elicitation content keys: " ~ ($form-response.content // {}).keys.join(', ');

    my $url-response = await $server.elicit-url(
        message => 'Open the approval UI',
        url => 'https://example.test/approve',
        elicitation-id => 'approval-1',
    );
    say "URL elicitation action: {$url-response.action}";

    $server.notify-elicitation-complete('approval-1');
}

my ($server-transport, $client-transport) = loopback-pair;

my $server = Server.new(
    info => Implementation.new(name => 'advanced-server', version => '0.1.0'),
    transport => $server-transport,
    page-size => 2,
    instructions => 'Loopback server for advanced client features',
);

# Seed enough data for pagination
for <alpha beta gamma delta epsilon> -> $name {
    $server.add-tool(
        name => "tool-$name",
        description => "Demo tool $name",
        handler => -> { "result-$name" },
    );
}

for <code-review explain summarize> -> $name {
    $server.add-prompt(
        name => $name,
        description => "Prompt $name",
        generator => -> :%params { "prompt-$name for " ~ (%params<topic> // 'general') },
    );
}

$server.add-resource(
    uri => 'file:///projects',
    name => 'Projects root',
    description => 'Root folder for projects',
    mimeType => 'text/plain',
    reader => { 'project listing placeholder' },
);

# Register completion handlers
$server.add-prompt-completer('code-review', -> $arg-name, $value, *%context {
    my @langs = <raku ruby rust python perl>;
    @langs.grep(*.starts-with($value.lc)).Array
});

$server.add-resource-completer('file:///projects', -> $arg-name, $value, *%context {
    my @paths = <project-a project-b prototype docs>;
    my @filtered = @paths.grep(*.starts-with($value.lc));
    CompletionResult.new(values => @filtered, total => @paths.elems, hasMore => False)
});

# Start server loop
$server.serve;

my @roots = [
    Root.new(uri => 'file:///project', name => 'Project'),
    Root.new(uri => 'file:///tmp', name => 'Temp'),
];

my $capabilities = ClientCapabilities.new(
    elicitation => ElicitationCapability.new(form => True, url => True),
);

my $client = Client.new(
    info => Implementation.new(name => 'advanced-client', version => '0.1.0'),
    transport => $client-transport,
    capabilities => $capabilities,
    roots => @roots,
    elicitation-handler => -> %params {
        ElicitationResponse.new(
            action => ElicitAccept,
            content => {
                name => 'Example User',
                approved => True,
                mode => %params<mode>,
            },
        )
    },
);

await $client.connect;

show-pagination($client);
show-completions($client);
show-roots-and-elicitation($server);

await $client.close;
await $client-transport.close;
await $server-transport.close;

say "\nDone.";


root

advanced-server

two-bugs-one-symptom

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<AI|file:../mcp/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


advanced-client

NAME

DESCRIPTION

USAGE

MCP v0.33.6

Authors

License

Dependencies

Test Dependencies

Provides

Documentation