I just released version 5 of Venus, (vns (https://github.com/usevenus/vns) on GitHub), along with two companion repos:

• bye: (https://github.com/usevenus/bye) An introduction to Venus by example
• cfu: (https://github.com/usevenus/cfu) A set of Claude Code instructions for writing Perl using Venus ideas and primitives

Venus is opinionated but pragmatic. The goal has always been to give modern Perl 5 developers a cohesive set of modern primitives for data modeling, validation, error handling, roles, CLI tooling, and functional-style helpers, without abandoning Perl idioms or core sensibilities.

v5 is the largest release so far and includes both new features and some intentional breaking changes to clean up long-standing design constraints.

Highlights from v5.01:

• First class support for private instance data
• Thoroughly documented type system and parser, see Venus::Type (https://metacpan.org/pod/Venus::Type), Venus::Check (https://metacpan.org/pod/Venus::Check)
• New core utilities: Venus::Map (https://metacpan.org/pod/Venus::Map), Venus::Set (https://metacpan.org/pod/Venus::Set), Venus::Range (https://metacpan.org/pod/Venus::Range), Venus::Collect (https://metacpan.org/pod/Venus::Collect), Venus::Result (https://metacpan.org/pod/Venus::Result)
• Myriad ways to validate data, e.g., Venus::Data (https://metacpan.org/pod/Venus::Data), Venus::Validate (https://metacpan.org/pod/Venus::Validate), and Venus::Schema (https://metacpan.org/pod/Venus::Schema)
• Improved error and fault handling with Venus::Error (https://metacpan.org/pod/Venus::Error), Venus::Try (https://metacpan.org/pod/Venus::Try), and Resultable roles
• Keyword functions like gets (https://metacpan.org/pod/Venus#gets), sets (https://metacpan.org/pod/Venus#sets), mask (https://metacpan.org/pod/Venus#mask), kvargs (https://metacpan.org/pod/Venus#kvargs), unpack (https://metacpan.org/pod/Venus#unpack), and cli (https://metacpan.org/pod/Venus#cli)
• Refactored container and factory model (i.e., dependency injection)
• Method modifiers, lifecycle hooks, coercion-by-type, and richer role composition
• A much more capable CLI framework with routing, dispatching, and spec-driven configuration
• Better configuration handling, including support for .env files and multiline environment variables
• Significant internal refactors to simplify extension and documentation
• Overhauled test framework with more features, automation, and POD generation

This project is very much for people who still like Perl, want stronger structure, and prefer libraries that help you model intent rather than just shuffle data.

Feedback, criticism, and questions are all welcome. If nothing else, I hope it sparks some interesting discussion about what "modern Perl" can look like today.

Weekly Challenge 357

Each week Mohammad S. Anwar sends out The Weekly Challenge, a chance for all of us to come up with solutions to two weekly tasks. My solutions are written in Python first, and then converted to Perl. It's a great way for us all to practice some coding.

Challenge, My solutions

Task 1: Kaprekar Constant

Task

Write a function that takes a 4-digit integer and returns how many iterations are required to reach Kaprekar's constant (6174).

My solution

This is where GitHub Copilot really scars me somewhat. Without mentioning "kaprekar" at all, and after typing while number != 6174: it auto-completed the rest of the code.

For this solution, I start by checking that the number is between 1 and 9999, and that it is not divisible by 1111. If any of these are false, I return -1.

I create a variable called count, starting at 0. If number is not 6174, I take the following steps

1. Set digits to be the individual digits, left padded with zeros if needed.
2. Set asc_digits to the above digits list, sorted numerically (lowest first). Set desc_digits to the same, but in reversed sorted order.
3. Set small_num to the integer that concatenates asc_digits.
4. Set large_num to the integer that concatenates desc_digits.
5. Set number to be large_num minus small_num.
6. If this is not 6174, repeat the loop again.

def kaprekar_constant(number: int) -> int:
    if not 0 < number < 10000:
        return -1

    if number % 1111 == 0:
        return -1

    count = 0
    while number != 6174:
        digits = [int(d) for d in str(number).zfill(4)]
        asc_digits = sorted(digits)
        desc_digits = sorted(digits, reverse=True)
        small_num = int(''.join(map(str, asc_digits)))
        large_num = int(''.join(map(str, desc_digits)))
        number = large_num - small_num
        count += 1

    return count

The Perl solution is a little shorter, as I don't need to worry about finicky things like converting integers to strings :P

sub main ($int) {
    if ($int < 1 or $int > 9999 or $int % 1111 == 0) {
        say -1;
        return;
    }

    my $count = 0;
    while ($int != 6174) {
        my $small_number = join("", sort { $a <=> $b } (split //, sprintf("%04d", $int)));
        my $big_number = reverse($small_number);
        $int = $big_number - $small_number;
        $count++
    }

    say $count;
}

Examples

$ ./ch-1.py 3524
3

$ ./ch-1.py 6174
0

$ ./ch-1.py 9998
5

$ ./ch-1.py 1001
4

$ ./ch-1.py 9000
4

$ ./ch-1.py 1111
-1

Task 2: Unique Fraction Generator

Task

Given a positive integer n, generate all unique fractions you can create using integers from 1 to n and follow the rules below:

• Use numbers 1 through n only (no zero)
• Create fractions like numerator/denominator
• List them in ascending order (from smallest to largest)
• If two fractions have the same value (like 1/2 and 2/4), only show the one with the smallest numerator

My solution

Python has the fractions module as standard, while Perl has a CPAN module called Numbers::Fraction.

Both exhibit the same behaviors:

• Takes the numerator (top part) and denominator (bottom part) as input variables
• Will automatically convert to have the lowest unique values. For example, Fraction(2, 4) automatically is Fraction(1, 2).
• Annoyingly for this task, will print a whole number if the denominator is 1.
• Two fractions variables can be compared to be sorted correctly (by the number they represent). For example ¼ < ½.

With that in mind, this task involves having a double loop for n and d (both from 1 to number), removing the duplicates with the set function, and then sorting them numerically. Finally, I turn the Fraction object into strings, and return the list.

def unique_fraction_generator(number: int) -> list[str]:
    fractions = sorted(set(
        Fraction(n,d)
        for d in range(1, number + 1)
        for n in range(1, number+1)
    ))

    return [f"{frac.numerator}/{frac.denominator}" for frac in fractions]

The Perl solution follows the same logic. It uses grep to check if a fraction is added previously, and pushes it to the fractions array if it is not.

use Number::Fraction;

sub main ($int) {
    my @fractions = ();
    foreach my $n (1 .. $int) {
        foreach my $d (1 .. $int) {
            my $fraction = Number::Fraction->new($n, $d);
            push @fractions, $fraction if not grep { $_ == $fraction} @fractions;
        }
    }

    my @sorted_fractions = sort { $a <=> $b } @fractions;
    say join(", ", map({ "$_->{num}/$_->{den}" } @sorted_fractions));
}

Examples

$ ./ch-2.py 3
1/3, 1/2, 2/3, 1/1, 3/2, 2/1, 3/1

$ ./ch-2.py 4
1/4, 1/3, 1/2, 2/3, 3/4, 1/1, 4/3, 3/2, 2/1, 3/1, 4/1

$ ./ch-2.py 1
1/1

$ ./ch-2.py 6
1/6, 1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5, 5/6, 1/1, 6/5, 5/4, 4/3, 3/2, 5/3, 2/1, 5/2, 3/1, 4/1, 5/1, 6/1

$ ./ch-2.py 5
1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5, 1/1, 5/4, 4/3, 3/2, 5/3, 2/1, 5/2, 3/1, 4/1, 5/1

Originally published at Perl Weekly 756

Hi there,

Perl continues to show remarkable momentum in early 2026, with Dean highlighting the language's improved position in the TIOBE Index, signaling renewed attention and ongoing relevance. This renewed visibility is supported by active development and innovative tooling, from Toby Inkster's performance-boosting Moose extensions to William McLean's demonstration of deploying Perl MCP servers on Cloud Run.

Community and ecosystem engagement remain strong, as seen with CosmoShop sponsoring the German Perl Workshop and the launch of the Thunderhorse web framework beta, offering modern features like WebSockets and SSE. Open-source contributions continue to thrive, exemplified by Corion's 2025 module releases and Robert Acock's work on practical data structures, helping developers build efficient, real-world applications.

The Perl community also places emphasis on knowledge-sharing and accessibility. Dave Cross's slide archives provide a wealth of training resources, while the Perl Ad Server enables easy promotion of community events, jobs, and podcasts, strengthening connections across the ecosystem.

Finally, discussions within the Perl Steering Council, such as those on experimental features like refaliasing and declared_refs, demonstrate ongoing efforts to evolve the language responsibly. Alongside a growing focus on transparency and sustainability, as highlighted in Makoto Nozaki's financial analysis of TPRF, these developments show a community that balances innovation, support, and stewardship.

Stay positive and healthy, enjoy rest of the newsletter.

--
Your editor: Mohammad Sajid Anwar.

Announcements

This week in PSC (211) | 2026-01-12

We mostly discussed the experimental refaliasing and declared_refs features to see if we can find a path towards declaring at least the latter non-experimental.

Cosmoshop supports the German Perl Workshop 2026

Max Maischein announces that CosmoShop, one of the world’s largest pure‑Perl shop systems, is once again sponsoring the German Perl Workshop in 2026, strengthening community support for this key Perl/Raku conference. This continued backing highlights the vibrant ecosystem and industry engagement around Perl events.

Thunderhorse Beta released!

The blog announces the beta release of Thunderhorse, a new Perl web framework drawing on lessons from Kelp and built natively on PAGI, with real‑time features like WebSocket and SSE support and a focus on extensibility and high code quality.

Slide archive: Learn with Dave Cross

Dave Cross has published an archive of slides from his long‑running technical training courses on Perl and other developer topics, going back many years and available for free download. These slide decks offer a valuable resource for anyone wanting concise, well‑structured material from experienced instruction.

The corner of Gabor

A couple of entries sneaked in by Gabor.

Perl code reading and open source contribution

One of the best ways to learn is by reading other people's code, making small contributions and getting feedback. That's exactly what we do at these online sessions. The next one taking place on January 24 in a Zoom near you. Join us!

Articles

What I released in 2025

In his year‑in‑review post, Corion reflects on a productive 2025 by highlighting several useful Perl modules he published, including Text::HTML::Turndown for converting HTML to Markdown and Date::Find for extracting dates from filenames. He also shares a paranoid Mojo::UserAgent extension and contributions to core modules, giving readers insight into both his releases and ongoing development work.

How can we make this Moose faster?

Toby Inkster introduces performance‑boosting extensions to Moose with MooseX::XSAccessor and the new MooseX::XSConstructor, showing significant speedups in object creation and method access. His benchmarks suggest up to ~76 % faster performance using XS‑based accessors and constructors, offering a practical way to accelerate Moose‑based Perl code.

Understanding TPRF's Finance, 2026 Edition

Makoto Nozaki takes a clear, numbers‑driven look at The Perl and Raku Foundation’s 2024 financials, showing a significant increase in revenue but expenses that far exceeded income and halved its assets. His breakdown highlights both positive trends in donations and a strong call for greater transparency to ensure the foundation’s long‑term sustainability.

Taking the Win - Perl in the TIOBE Index

Dean celebrates Perl’s improved position in the TIOBE Index during 2025 and highlights the ongoing momentum in the Perl community, from steady releases to vibrant events and tooling support. While acknowledging healthy skepticism about popularity metrics, he encourages readers to "take the win" and appreciate the positive signals for Perl’s ecosystem.

Firestore MCP Development with Perl, Cloud Run, and Gemini CLI

William McLean walks through building a minimal Perl‑based MCP (Model Context Protocol) server backed by Firestore, showing how to validate it locally and deploy it to Google Cloud Run using the Gemini CLI. The article highlights practical steps for integrating Perl with modern AI‑oriented workflows beyond the usual Python ecosystem and gives clear pointers for developers looking to experiment with MCP and Cloud Run deployments.

Doubly: Why Arrays Aren't Always Enough

Robert explores when traditional arrays fall short and makes a compelling case for using doubly linked lists instead, especially for operations like O(1) insertions and intuitive cursor navigation. Through Perl examples and performance trade‑offs across multiple implementations, from pure Perl to thread‑safe C registries, the article highlights practical data‑structure choices and when they pay off.

Perl Ad Server

The Perl Ad Server makes it easy to promote Perl‑related announcements, from events and podcasts to jobs and newsletters, by embedding a tiny JavaScript snippet that displays rotating banners on your website. It’s simple to style and control, and contributions are welcomed via GitHub for anyone who wants to add or manage ads for the community.

Grants

Maintaining Perl 5 Core (Dave Mitchell): December 2025

Maintaining Perl (Tony Cook) December 2025

PEVANS Core Perl 5: Grant Report for December 2025

The Weekly Challenge

The Weekly Challenge by Mohammad Sajid Anwar will help you step out of your comfort-zone. You can even win prize money of $50 by participating in the weekly challenge. We pick one champion at the end of the month from among all of the contributors during the month, thanks to the sponsor Lance Wicks.

The Weekly Challenge - 357

Welcome to a new week with a couple of fun tasks "Kaprekar Constant" and "Unique Fraction Generator". If you are new to the weekly challenge then why not join us and have fun every week. For more information, please read the FAQ.

RECAP - The Weekly Challenge - 356

Enjoy a quick recap of last week's contributions by Team PWC dealing with the "Kolakoski Sequence" and "Who Wins" tasks in Perl and Raku. You will find plenty of solutions to keep you busy.

Kolakoski Wins

The article clearly demonstrates a thoughtful Raku solution to generating the Kolakoski sequence and counting 1s, leveraging Raku’s gather/take constructs for elegant lazy sequence generation. The examples and code comments make the approach easy to understand.

Perl Weekly Challenge: Week 356

The post delivers a technically clear explanation of both the Kolakoski Sequence and Who Wins tasks with illustrative examples and thoughtful insight into simplifying the problem logic—showcasing an effective balance between correctness and practical Perl coding. The walkthroughs help demystify the challenge specifications and offer useful implementation perspectives for Perl developers.

Self-Generating Games

The post delivers clear, well-structured solutions to both tasks, especially with its concise explanation of generating the Kolakoski sequence and counting elements. The breakdowns and examples make the logic easy to follow and practically useful for coding challenges.

Perl Weekly Challenge 356

The post showcases concise and effective Perl implementations for both the Kolakoski‑Sequence and Who‑Wins tasks, with a compact self‑referential sequence generator and a structured playoff progression model. The code is thoughtfully organised and demonstrates practical mastery of sequence construction and game logic within Perl’s syntax.

Kolakoski called, he wants his sequence back(!)

The post offers a thoughtful, well-commented Perl exploration of the Kolakoski sequence that breaks down the generation logic with clear analogies and illustrative code, making the algorithm approachable even for those new to the concept. Its lively explanation paired with working examples enhances understanding and practical problem-solving.

Who’s Kolakoski?

The write-up presents a thoughtful multilingual exploration of the Kolakoski challenge with clear logic and practical code that demonstrates command over sequence generation and problem constraints, making it both accessible and instructive. Packy’s commentary and stepwise approach enhance readability and offer valuable insights for anyone tackling the Weekly Challenge tasks.

Sequence and consequence

The post provides a clear, well-reasoned implementation of both tasks, with the Kolakoski solution closely following the Wikipedia algorithm and demonstrating impressive performance at scale. The NFL playoff logic is neatly modeled with concise Perl code, showing careful handling of seeding, sorting, and edge cases in a readable and maintainable way.

The Weekly Challenge #356

The post offers clear, well-structured Perl solutions for both the Kolakoski sequence and "Who Wins" tasks, closely following the problem definitions with readable logic and solid use of Perl idioms. The explanations make the algorithms accessible while the included references help ground the implementation in established techniques.

Kolakoski Wins

The post presents elegant and thoughtfully implemented solutions to both tasks, with the Kolakoski sequence logic clearly articulated and efficiently expressed in Raku. The playoff "Who Wins" solution demonstrates solid handling of round progression and seed logic, showcasing clean algorithm design and practical Rust usage.

Winning sequence

The write-up delivers concise and effective Python solutions for both the Kolakoski Sequence and Who Wins tasks, with a clever analytical shortcut for the sequence count and a clean stepwise modeling of the playoff progression. The inclusion of examples and clear logic makes the implementations easy to follow and practically useful.

Rakudo

2026.02 Resolutions

Weekly collections

NICEPERL's lists

Great CPAN modules released last week;
MetaCPAN weekly report.

Events

Perl Maven online: Live Open Source contribution

January 24, 2025

Boston.pm - online

February 10, 2025

German Perl/Raku Workshop 2026 in Berlin

March 16-18, 2025

You joined the Perl Weekly to get weekly e-mails about the Perl programming language and related topics.

Want to see more? See the archives of all the issues.

Not yet subscribed to the newsletter? Join us free of charge!

(C) Copyright Gabor Szabo
The articles are copyright the respective authors.

Leveraging Gemini CLI and the underlying Gemini LLM to build Model Context Protocol (MCP) AI applications in Perl with Google Cloud Run.

Why not just use Python?

Python has traditionally been the main coding language for ML and AI tools. One of the strengths of the MCP protocol is that the actual implementation details are independent of the development language. The reality is that not every project is coded in Python- and MCP allows you to use the latest AI approaches with other coding languages.

Perl? Is that even a language anymore?

The goal of this article is to provide a minimal viable basic working MCP server in Perl that can be run locally without any unneeded extra code or extensions.

The Perl MCP module is here:

MCP-0.06

What Is Perl?

Perl is a general-purpose, high-level programming and scripting language, primarily known for its powerful text manipulation capabilities. Originally created by Larry Wall in 1987 for easier report processing, it has evolved to be used for a wide range of tasks, including system administration, web development, and network programming.

The main site for Perl is :

The Perl Programming Language - www.perl.org

Installing Perl

The step by step instructions vary by platform- for a basic Debian system here are the steps:

sudo apt-get install perl cpanminus

xbill@penguin:~/gemini-cli-codeassist/firstore-https-perl$ perl --version

This is perl 5, version 36, subversion 0 (v5.36.0) built for x86_64-linux-gnu-thread-multi
(with 60 registered patches, see perl -V for more detail)

Gemini CLI

If not pre-installed you can download the Gemini CLI to interact with the source files and provide real-time assistance:

npm install -g @google/gemini-cli

Testing the Gemini CLI Environment

Once you have all the tools and the correct Node.js version in place- you can test the startup of Gemini CLI. You will need to authenticate with a Key or your Google Account:

gemini

Node Version Management

Gemini CLI needs a consistent, up to date version of Node. The nvm command can be used to get a standard Node environment:

GitHub - nvm-sh/nvm: Node Version Manager - POSIX-compliant bash script to manage multiple active node.js versions

Perl MCP Documentation

The official MCP CPAN page provides samples and documentation for getting started:

MCP

Where do I start?

The strategy for starting MCP development is a incremental step by step approach.

First, the basic development environment is setup with the required system variables, and a working Gemini CLI configuration.

Then, a minimal Hello World Style Perl MCP Server is built with HTTP transport. This server is validated with Gemini CLI in the local environment.

This setup validates the connection from Gemini CLI to the local process via MCP. The MCP client (Gemini CLI) and the MCP server both run in the same local environment.

Next- the basic MCP server is extended with Gemini CLI to add several new tools in standard code.

Setup the Basic Environment

At this point you should have a working Perl environment and a working Gemini CLI installation. The next step is to clone the GitHub samples repository with support scripts:

cd ~
git clone https://github.com/xbill9/gemini-cli-codeassist

Then run init.sh from the cloned directory.

The script will attempt to determine your shell environment and set the correct variables:

cd gemini-cli-codeassist
source init.sh

If your session times out or you need to re-authenticate- you can run the set_env.sh script to reset your environment variables:

cd gemini-cli-codeassist
source set_env.sh

Variables like PROJECT_ID need to be setup for use in the various build scripts- so the set_env script can be used to reset the environment if you time-out.

Hello World with HTTP Transport

One of the key features that the standard MCP libraries provide is abstracting various transport methods.

The high level MCP tool implementation is the same no matter what low level transport channel/method that the MCP Client uses to connect to a MCP Server.

The simplest transport that the SDK supports is the stdio (stdio/stdout) transport — which connects a locally running process. Both the MCP client and MCP Server must be running in the same environment.

The HTTP MCP transport allows the client and server to be on the same machine or distributed over the Internet.

The connection over HTTP will look similar to this:

# Use HTTP transport via Mojolicious
any '/mcp' => $server->to_action;

Perl Package Information

The Perl code depends on several standard libraries for MCP and logging:

requires 'Mojolicious::Lite';
requires 'MCP::Server';
requires 'JSON::MaybeXS';
requires 'WWW::Google::Cloud::Auth::ServiceAccount';
requires 'URI::Encode';
requires 'LWP::Protocol::https';

Installing and Running the Perl Code

Run the install make release target on the local system:

xbill@penguin:~/gemini-cli-codeassist/firestore-https-perl$ make
Installing dependencies...
--> Working on .
Configuring /home/xbill/gemini-cli-codeassist/firestore-https-perl ... OK
<== Installed dependencies for .. Finishing.
Running tests...
t/00_compile.t ................... ok   
t/01_firestore_client_compile.t .. ok   
All tests successful.
Files=2, Tests=2, 0 wallclock secs ( 0.01 usr 0.01 sys + 0.34 cusr 0.05 csys = 0.41 CPU)
Result: PASS

To test the code:

xbill@penguin:~/gemini-cli-codeassist/firestore-https-perl$ make test
Running tests...
t/00_compile.t .. ok   
All tests successful.
Files=1, Tests=1, 0 wallclock secs ( 0.02 usr 0.00 sys + 0.19 cusr 0.05 csys = 0.26 CPU)
Result: PASS

Gemini CLI settings.json

In this example — the Perl source code uses a Perl interpreter that can be called directly from Gemini CLI.

The default Gemini CLI settings.json has an entry for the source:

 {
    "mcpServers": {
    "firebase-https-perl": {
      "httpUrl": "http://127.0.0.1:8080/mcp"
    }
  }
}

Start the Local Server

Open a new terminal to run the local MCP Perl server :

xbill@penguin:~/gemini-cli-codeassist/firestore-https-perl$ make run
Running the application...
{"asctime":"2026-01-12T22:10:06.21872Z","levelname":"INFO","message":"Initializing Firestore for project: comglitn","name":"root"}
{"asctime":"2026-01-12T22:10:06.2188Z","levelname":"INFO","message":"Firestore initialized successfully","name":"root"}
{"asctime":"2026-01-12T22:10:06.21881Z","levelname":"INFO","message":"Starting MCP server","name":"root"}
{"asctime":"2026-01-12T22:10:06.22059Z","levelname":"INFO","message":"Listening at \"http://0.0.0.0:8080\"","name":"root"}
Web application available at http://0.0.0.0:8080

Validation with Gemini CLI

Leave the local server running and open a new Terminal window. Gemini CLI is used to validate the MCP connection over HTTP to the Perl Code:

> /mcp list

Configured MCP servers:

🟢 firebase-https-perl - Ready (8 tools)
  Tools:
  - add_product
  - batch_delete
  - delete_product
  - find_products
  - get_product
  - greet
  - list_products
  - update_product

> find_products Coffee

✦ I will search for products matching "Coffee".
╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ? find_products (firebase-https-perl MCP Server) {"name":"Coffee"} ← │
│ │
│ MCP Server: firebase-https-perl │
│ Tool: find_products │
│ │
│ Allow execution of MCP tool "find_products" from server "firebase-https-perl"? │
│ │
│ 1. Allow once │
│ 2. Allow tool for this session │
│ ● 3. Allow all server tools for this session │
│ 4. No, suggest changes (esc) │
│ │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

✦ I will search for "Coffee Beans" specifically, as it exists in the inventory.
╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ find_products (firebase-https-perl MCP Server) {"name":"Coffee Beans"} │
│ │
│ {"products":[{"actualdateadded":"2026-01-07T16:53:00.672Z","id":"37kWbZHTwg5nbrSD13PB","imgfile":"product-images\/coffeebeans. │
│ png","name":"Coffee Beans","price":6,"quantity":375,"timestamp":"2024-11-30T08:40:02.515Z"}]} │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I found the product you were looking for: Coffee Beans (ID: 37kWbZHTwg5nbrSD13PB). It is priced at $6 and there are 375 in
  stock.

Deploying to Cloud Run

After the HTTP version of the MCP server has been tested locally — it can be deployed remotely to Google Cloud Run.

First- switch to the directory with the HTTP MCP sample code:

cd ~/gemini-cli-codeassist/firestore-https-perl

Deploy the project to Google Cloud Run with the pre-built cloudbuild.yaml and Dockerfile:

cd ~/gemini-cli-codeassist/firestore-https-perl
xbill@penguin:~/gemini-cli-codeassist/firestore-https-perl$ make deploy

The Cloud Build will start:

> make deploy

✦ I will read the Makefile to understand the deployment process and then execute make deploy.

╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile Makefile │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I will read cloudbuild.yaml to verify the build configuration.

╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile cloudbuild.yaml │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I will execute make deploy to submit the build to Google Cloud Build.

✦ I will execute make deploy to submit the build to Google Cloud Build and deploy the application.

╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ⊶ Shell make deploy [current working directory /home/xbill/gemini-cli-codeassist/firestore-https-perl] (Submit build to Goog… │
│ │
│ Step #0: 7703c2863431: Pulling fs layer │
│ Step #0: d4d869c8f88d: Pulling fs layer │
│ Step #0: 8b22c905be5d: Pulling fs layer │
│ Step #0: 8b22c905be5d: Waiting │
│ Step #0: 7703c2863431: Download complete │
│ Step #0: 8b22c905be5d: Verifying Checksum │
│ Step #0: 8b22c905be5d: Download complete │
│ Step #0: d4d869c8f88d: Verifying Checksum │
│ Step #0: d4d869c8f88d: Download complete │
│ Step #0: 7bbf972c6c2f: Verifying Checksum │
│ Step #0: 7bbf972c6c2f: Download complete │
│ │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

It can take 15–30 minutes to complete the build.

The cloud build needs to pull in all Perl libraries in the build environment and generate the entire package from scratch.

When the build is complete- an endpoint will be returned:

│ Starting Step #2 │
│ Step #2: Already have image (with digest): gcr.io/cloud-builders/gcloud │
│ Step #2: Deploying container to Cloud Run service [firestore-https-perl] in project [comglitn] region [us-central1] │
│ Step #2: Deploying... │
│ Step #2: Setting IAM Policy.........done │
│ Step #2: Creating │
│ Revision...................................................................................................................... │
│ .............................................................................................................................. │
│ .................done │
│ Step #2: Routing traffic.....done │
│ Step #2: Done. │
│ Step #2: Service [firestore-https-perl] revision [firestore-https-perl-00002-v5g] has been deployed and is serving 100 percent │
│ of traffic. │
│ Step #2: Service URL: https://firestore-https-perl-1056842563084.us-central1.run.app │
│ Finished Step #2 │
│ PUSH │
│ Pushing gcr.io/comglitn/firestore-https-perl:latest │
│ The push refers to repository [gcr.io/comglitn/firestore-https-perl] │

The service endpoint in this example is :

https://firestore-https-perl-1056842563084.us-central1.run.app

The actual endpoint will vary based on your project settings.

Review Service in Cloud Run

Navigate to the Google Cloud console and search for Cloud Run -

and then you can detailed information on the Cloud Run Service:

Cloud Logging

The remote server writes logs to stderr in standard JSON format. These logs are available from the deployed Cloud Run Service:

Validate HTTP connection

Once you have the Endpoint — you can attempt a connection- navigate to in your browser:

https://firestore-https-perl-1056842563084.us-central1.run.app

You will need to adjust the exact URL to match the URL returned from Cloud Build.

You will get an error- this connection is expecting a message in the MCP format:

Not Found

Gemini CLI settings.json.cloudrun

Replace the default Gemini CLI configuration file —  settings.json with a pre-configured sample- settings.json.cloudrun to use the Cloud Run version of the connection:

 {
    "mcpServers": {
    "firestore-cloudrun-perl": {
      "httpUrl": "https://firestore-https-perl-$PROJECT_NUMBER.us-central1.run.app/mcp"
    }
  }
}

Copy the Cloud Run version of the Gemini CLI configuration file:

xbill@penguin:~/gemini-cli-codeassist/firestore-https-perl$ cd .gemini
cp settings.json.cloudrun settings.json
xbill@penguin:~/gemini-cli-codeassist/firestore-https-perl/.gemini$

Validation with Gemini CLI

The final connection test uses Gemini CLI as a MCP client with the deployed Cloud Run Service in Perl providing the MCP server. Startup Gemini CLI with the updated settings :

gemini

> /mcp list

Configured MCP servers:

🟢 firestore-cloudrun-perl - Ready (8 tools)
  Tools:
  - add_product
  - batch_delete
  - delete_product
  - find_products
  - get_product
  - greet
  - list_products
  - update_product

✦ I have retrieved the list of products from the inventory. There are currently 34 products available, ranging from fresh produce
  like Apples and Bananas to pantry staples like Rice and Coffee Beans. Some items, such as Wasabi Party Mix and Jalapeno
  Seasoning, are currently out of stock.

> how can I generate the most revenue from my inventory?

✦ Based on your current inventory, here is a breakdown of how to maximize revenue:

  Top Revenue Drivers (High Price × High Volume)
  These products currently hold the most value in your inventory. Prioritize selling these to unlock the most cash flow.
   1. Whole Wheat Bread ($3,280 potential) — High price ($10) and good stock.
   2. Pineapple Kombucha ($3,216 potential) — Premium price ($8) with high volume.
   3. Green Tea ($2,844 potential) — Mid-range price ($6) but very high quantity.
   4. Beef ($2,380 potential) — High price ($10) item.
   5. Maple Almond Butter ($2,355 potential).

  Strategic Opportunities
   * Restock Alerts:
       * Wasabi Party Mix and Jalapeno Seasoning are completely out of stock ($0 revenue).
       * Walnuts (2 left) and Smores Cereal (23 left) are running low. Walnuts are a higher-price item ($7), so missing sales here
         is a lost opportunity.
   * Volume Movers (High Quantity / Low Price):
       * Eggs (496 units @ $1) and Black Beans (486 units @ $3) are abundant. Consider bundling these or running "buy one get one"
         promotions to clear space and generate liquidity.
   * Premium Items:
       * Cola and Whole Chicken are priced at $10. Even small increases in sales volume for these items will significantly impact
         your bottom line.

Summary

MCP development with Perl using Gemini CLI was validated with an incremental step by step approach.

A minimal streaming HTTP transport MCP Server was built from source code and validated with Gemini CLI running as a MCP client in the same local environment.

Then — the MCP server was wrapped in a container and submitted to Google Cloud Build for deployment to Google Cloud Run. The remote MCP server was validated with a standard browser, and Gemini CLI.

Finally- remote MCP operations were performed from the local Gemini CLI installation to the Perl MCP server hosted in Google Cloud Run.

This approach can be extended to more complex deployments and Cloud based options.

Thunderhorse framework was just released as beta. Read more about it on my blog: https://bbrtj.eu/blog/article/thunderhorse-beta-released