Coder Legion - Recent posts tagged gemini

I Built ArchShield: An AI Architecture & Security Baseline Assistant.

Mon, 26 Oct 2026 01:35:09 +0000

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

I built ArchShield, an AI-powered architecture visualizer and security baseline assistant for developers.

The goal was to turn a natural-language software architecture description into a structured, interactive architecture diagram while also checking for basic security controls across the detected components.

The main prompt I used was:

Build a web application called ArchShield that analyzes a software architecture described in natural language. Identify components such as frontend, backend/API, database, cache, authentication, storage, external services, AI/LLM providers, and CDN/WAF. Visualize the architecture as an interactive multi-tier technical diagram with communication paths and network exposure. Add a basic security baseline review that distinguishes CONFIRMED, NOT MENTIONED, POTENTIAL CONCERN, and NOT APPLICABLE controls. Provide actionable security recommendations and integrate Imagen to generate a visual architectural blueprint.

I then iterated on the generated application to refine the architecture visualization, security analysis, error handling, and generated blueprint experience.

Demo

Live application: https://archshield.ai.studio

ArchShield can:

Interpret architecture descriptions using Gemini
Detect frontend, backend, databases, caches, authentication, storage, external services, AI/LLM providers, and edge components
Render an interactive multi-tier architecture diagram
Inspect individual architecture components
Perform a basic security baseline review
Generate actionable security recommendations
Generate a visual architecture blueprint using Imagen
Export architecture and security information as Markdown and JSON

My Experience

This track was a great demonstration of how quickly an AI-assisted development workflow can move from an idea to a working application.

What surprised me most was not the initial code generation, but the iterative workflow. Gemini could generate a functional application quickly, but getting the result to behave exactly as intended still required testing, inspecting failures, and refining the instructions.

I also ran into an XML parsing issue during the process. Instead of treating the generated application as finished once it worked in the preview, I used the error output to guide another iteration and corrected the generated implementation.

The project also made me think about the difference between generating an application and engineering one. A working UI is only part of the result. Clear boundaries, predictable behavior, useful security guidance, and honest handling of uncertainty matter just as much.

ArchShield deliberately treats NOT MENTIONED differently from POTENTIAL CONCERN: the absence of evidence is not automatically treated as evidence of a vulnerability.

Overall, the track gave me a practical look at Google AI Studio's Build workflow and how Gemini can act as an implementation partner while still requiring engineering judgment, testing, and iteration from the developer.

Most people use AI wrong: Stop pasting raw links and hoping for magic.

Sun, 18 Oct 2026 17:12:22 +0000

You read 10 articles, highlight sentences, copy fragments into notes, open 5 tabs, and manually assemble prompts.

It kills your focus.

So I built MindContext — the local-first AI research copilot for Chrome. 🧵👇

1/ 💡 How it works:
While reading any webpage, take instant notes & highlight key quotes directly in a sleek side panel.

With one click, MindContext compiles your clean article text + thoughts + quotes into a structured AI handoff prompt.

No formatting hassle. No lost context.

2/ 🎯 Structured AI Handoffs:
Stop getting generic AI answers.

Choose from curated prompt frameworks right inside your browser:
• Executive Summary (distinguish facts from hype)
• Critical Analysis & Counterarguments
• Action Items & Next Steps
• Multi-Source Synthesis

3/ 🚀 Take it to the next level with MindContext PRO:

For serious researchers, founders, and knowledge workers:

📺 YouTube Full Transcripts: Turn 2-hour podcast or technical talk transcripts into structured AI context in 2 seconds.
📁 Unlimited Research Projects: Group notes & quotes across dozens of tabs for comparative cross-source synthesis.
🎨 4-Color Smart Highlighter: Color-code ideas, facts, bugs, or competitors — click any quote to jump directly to its exact spot on the page!
⚡ Saved Chat Links: Automatically routes prompts straight into your ongoing ChatGPT/Claude/Gemini chats instead of spamming new conversations.

4/ 🔒 100% Privacy-First by Design:
Your notes and research NEVER touch external servers. Everything lives locally in your browser sandbox (chrome.storage.local). Zero tracking, zero cloud dependencies.

Try MindContext Free on the Chrome Web Store:
👉 chromewebstore.google.com/detail/mindcontext-ai-research-n/nmagjifaanaaddbogdebppjdcoaignnd

Unlock Pro for just $24/year (~$2/mo):
⚡ [Link to Lemon Squeezy / Store]

buildinpublic #AI #productivity #ChatGPT #Claude #ChromeExtension #PKM

Copy-pasting research into ChatGPT, Claude, or Gemini is broken!

Sun, 18 Oct 2026 17:10:04 +0000

You read 10 articles, highlight sentences, copy fragments into notes, open 5 tabs, and manually assemble prompts.

It kills your focus.

So I built MindContext — the local-first AI research copilot for Chrome. 🧵👇

1/ 💡 How it works:
While reading any webpage, take instant notes & highlight key quotes directly in a sleek side panel.

With one click, MindContext compiles your clean article text + thoughts + quotes into a structured AI handoff prompt.

No formatting hassle. No lost context.

2/ 🎯 Structured AI Handoffs:
Stop getting generic AI answers.

3/ 🚀 Take it to the next level with MindContext PRO:

For serious researchers, founders, and knowledge workers:

Try MindContext Free on the Chrome Web Store:
👉 chromewebstore.google.com/detail/mindcontext-ai-research-n/nmagjifaanaaddbogdebppjdcoaignnd

Unlock Pro for just $24/year (~$2/mo):
⚡ [Link to Lemon Squeezy / Store]

buildinpublic #AI #productivity #ChatGPT #Claude #ChromeExtension #PKM

Gemini 3.1 Pro Is Gone From My Antigravity Model Selector. Here's What I Can (and Can't) Confirm

Tue, 13 Oct 2026 06:31:47 +0000

Gemini 3.1 Pro quietly disappeared from Google Antigravity. Here is what is confirmed, what isn't, and real-world web dev notes on Gemini 3.8 Flash (High).

On October 13, 2026, I opened the model selector in Google Antigravity and found a single Gemini option: Gemini 3.8 Flash. Gemini 3.1 Pro, the model I used to treat as the safe, top-of-the-list choice, was not there.

Google Antigravity model only showing Gemini 3.8 Flash

I wasn't surprised, but I want to explain why without claiming more than I know. Google hasn't said why this happened, and some of the picture is still unclear.

1. What's Confirmed, and What Isn't

Confirmed in my account: The selector shows 3.8 Flash as the only Gemini model on my Google One AI Premium plan (which includes Antigravity access). On the same day, another user posted on Google's developer forum that 3.1 Pro had quietly disappeared for subscribers after a recent update, leaving 3.8 Flash as the only Gemini choice.
Not confirmed: That this is permanent, or that it applies to every tier. In the most recent versions I could find, Antigravity's own models documentation still listed 3.1 Pro across all plans, and the Gemini API deprecations page showed no shutdown date for gemini-3.1-pro-preview. So either the documentation lags behind the product, or this is a phased rollout that hasn't reached everyone. I haven't found an official announcement yet.

2. A Pattern, Not a One-Off

Two things point in the same direction, even if neither conclusively proves Google's internal reasoning:

Cadence: Gemini 3.1 Pro was released on February 19, 2026, and as far as I can find it is still Google's latest Pro-tier model. Over the same months, Flash went through 3.5 (May 19), 3.6, 3.7, and 3.8 (early September). That is four Flash releases in under four months, with no new Pro in between.
The wider lineup is being trimmed: Antigravity's models page carries a note that some models will be removed on November 2, 2026. The "Notice" badges beside certain third-party models (like older Claude variants) similarly point to an active consolidation of the selector lineup.

Possible explanations include compute costs, simplifying the catalog before a next-generation launch, or Google's conviction that Flash is now capable enough for primary workflows. None of these has been officially confirmed.

3. What My Own Experience Adds, and What It Doesn't

My work is mostly Excel VBA and web apps. I used to pick the highest model with the highest thinking mode by default. When I stepped down to Gemini 3.7 Flash (High), in day-to-day tasks I didn't hit a wall I could pin on the model (large rewrites were the exception, discussed below). I described those results in my earlier posts on dev.to and Medium.

The main shift between versions was in reasoning: 3.7 Flash frequently struggled with complex problem-solving and nuanced debugging, whereas 3.8 Flash significantly closed that gap—resolving tricky multi-step logic on the first attempt without sacrificing Flash's rapid turnaround.

The limits matter. This is one developer doing two specific kinds of work, mostly with well-structured tasks. My prompting also improved over the same period, and Antigravity itself kept changing. It is a data point, not a verdict.

There is one more distinction: choosing Flash because it worked for me is a preference. Having Flash as the only Gemini option is not a preference, and I shouldn't treat the two as the same evidence.

4. Notes on 3.8 Flash (High) for Web Development

With Gemini 3.8 Flash on High thinking mode currently standing as the top Gemini option in my selector, my notes as a web developer come down to five points:

It is very fast: Agent loops stay quick, making small iterations cheap and responsive.
It reads large context well: It ingests a large portion of a project at once, so I rarely have to feed it files piece by piece.
Large rewrites are where it breaks: When I ask for a major architectural overhaul in one go, bugs tend to emerge. It works much better when I split the job into small modules and fix them one at a time.
Its visual design is not very creative on its own: For a clean, modern interface, I usually provide reference images or design tokens, and the output quality improves dramatically.
It is very dependable at automating document files: Despite its utilitarian design sense, I have found it remarkably reliable for working with .docx and .xlsx files, maintaining clean, well-structured layouts.

Concrete Example: During a database migration from a local setup to the cloud for our POS and accounting reporting system at setvy.id, asking 3.8 Flash to handle the entire shift in one massive pass resulted in a cascade of subtle query bugs and broken balance calculations. I had to step back and tackle the job in small, isolated slices—migrating one schema at a time, patching individual endpoints, and verifying the accounting logic module by module. Handled in small pieces, it was fast and reliable; tasked with the entire overhaul at once, it struggled.

This third point lines up with the forum user's report in one respect: both of us ran into trouble when the change scope was too broad.

5. The Other Side

The forum user who reported the missing model had the opposite experience. On a medium-sized project, they reported that 3.8 Flash invented APIs, edited unrelated files, and got stuck in read-and-think loops that drained quota—prompting them to revert with Git and return to 3.1 Pro. It is the same kind of critique I previously leveled against 3.1 Pro, mirrored in reverse.

Outside testing reflects this mixed reality:

Harness dependency: One hands-on review concludes that 3.8 Flash suits cost-sensitive, well-scoped coding tasks, noting that results depend heavily on the harness—performing noticeably better inside an agentic environment like Antigravity than in standard chat.
Benchmark ceiling: The same review notes that 3.8 Flash trails Opus 5 and GPT-5.6 on the harder Terminal-Bench 4.0, observing that its 89.4% headline score stems from Terminal-Bench 2.1, a benchmark widely considered saturated.

My working hypothesis (not a definitive finding): Flash holds up exceptionally well on scoped tasks (like a workbook, an API route, or a single module), but strains on large codebases where deep, cross-file interdependencies are at play.

6. What I'd Do Now

Check your own selector and plan: Take a dated screenshot so you have a baseline for what changed.
Commit to Git frequently: Keep agent iterations short so that an erratic run is cheap to rollback.
Keep tasks tightly scoped: State constraints explicitly (tenant IDs, soft-delete flags, precise table names).
Maintain a fallback strategy: Be aware of what alternative models are available in Antigravity as lineups shift.
Test on your own stack: Benchmark against your actual daily code rather than relying solely on generic benchmark charts.

A Question for You

When did you last genuinely need the top-tier Pro model, and would the outcome have been different with a better-scoped prompt and smaller iterations?

Has Gemini 3.1 Pro disappeared from your Antigravity selector as well? Let me know your experience and subscription plan in the comments below!

About the Author: Achmad Junaedi is a web developer and founder of setvy, building custom web applications, database architectures, and operational automation.

Sources & References

AudioFlow- STT and TTS tool

Wed, 07 Oct 2026 06:52:22 +0000

Welcome to AudioFlow in this app i created 2 simple ai tools that u can use in daily life

Voise to Text (STT)
Text to Voise (TTS)

This project is completely open-source so u can re-use this tools for your any kind of chatbot project

features of this app

Real-time audio streaming using web-socket
Reactive waveform which improve UX
Keeps Audio and Transaction history in local-storage

How to use this app ?
both tools are use Gemini models so u need to provide an api key it free generous tier for you personal use and it safely stored in local storage.

Live Demo: website-link
GitHub Repository: repo-link
Video Demo: video-link

Building a Real-Time Social Listening & Brand Sentiment Engine with Python, Gemini 1.5, and DuckDB

Sun, 04 Oct 2026 16:57:35 +0000

Enterprise social listening platforms like Brandwatch or Sprout charge upwards of $800 to $2,000/month per seat. Under the hood, many still rely on brittle dictionary lookup tables (VADER-style positive/negative lexical scoring) or generic regex filters. When a developer tweets "Oh fantastic, another breaking API change deployed straight to prod on a Friday!", classical sentiment classifiers mark it as overwhelmingly positive due to "fantastic".

Meanwhile, writing your own real-time monitoring service often degrades into a distributed systems mess: rate limits across Reddit and Hacker News, unstructured LLM hallucinations, deduplication bottlenecks, and ballooning database costs.

Here is how to build an asynchronous, production-ready brand intelligence engine using Python, Google's Gemini 1.5 Flash structured outputs, and DuckDB—running for less than $1/month in API costs.

1. The Architecture

The engine is designed around a decoupled, non-blocking ingestion and evaluation pattern:

graph TD
    A[Reddit API / HN Firebase / Bluesky Firehose / RSS] -->|Async Polling| B[Ingestion Layer: Asyncio + HTTPX]
    B -->|Content Hash SHA-256| C[(DuckDB Local Store - Deduplication)]
    C -->|New Items| D[Gemini 1.5 Flash Engine]
    D -->|Pydantic Structured JSON| E[Alert Dispatcher]
    E -->|Urgency >= High or Polarity <= -0.6| F[Slack / Discord Webhook]
    E -->|Daily Rollup & Trend Metrics| G[Parquet / Analytical Store]

Core Pillars:

Async Multi-Source Ingestion: Pulls from Reddit (asyncpraw), Hacker News (Firebase REST API), Bluesky (AT Protocol firehose), and custom RSS feeds asynchronously.
Deduplication Engine: Generates an identity fingerprint (sha256(platform + post_id)) checked against local embedded DuckDB before hitting LLM inference.
Structured Gemini 1.5 Flash Parsing: Uses schema-constrained JSON outputs to extract polarity (-1.0 to 1.0), urgency classification (low, medium, critical), entity references, and sarcasm detection.
Downstream Alert Dispatcher: Routes critical events directly to Slack/Discord webhooks while appending all metadata into DuckDB for fast OLAP rollups.

2. Ingestion & Deduplication via DuckDB

Rather than spinning up Postgres or Redis for transient social data, we use DuckDB. DuckDB runs in-process, provides zero-latency ACID writes, and allows vector-like analytical SQL on JSON columns.

import duckdb
import hashlib

class StorageManager:
    def __init__(self, db_path: str = "brand_intel.duckdb"):
        self.con = duckdb.connect(db_path)
        self._init_schema()

    def _init_schema(self):
        self.con.execute("""
            CREATE TABLE IF NOT EXISTS raw_mentions (
                id VARCHAR PRIMARY KEY,
                platform VARCHAR,
                author VARCHAR,
                content VARCHAR,
                url VARCHAR,
                created_at TIMESTAMP,
                processed BOOLEAN DEFAULT FALSE
            );
            CREATE TABLE IF NOT EXISTS sentiment_results (
                id VARCHAR PRIMARY KEY,
                polarity FLOAT,
                urgency VARCHAR,
                is_sarcastic BOOLEAN,
                entities JSON,
                summary VARCHAR,
                evaluated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (id) REFERENCES raw_mentions(id)
            );
        """)

    def is_duplicate(self, platform: str, external_id: str) -> bool:
        uid = hashlib.sha256(f"{platform}:{external_id}".encode()).hexdigest()
        res = self.con.execute("SELECT 1 FROM raw_mentions WHERE id = ?", [uid]).fetchone()
        return res is not None

    def insert_mention(self, platform: str, external_id: str, author: str, content: str, url: str, created_at):
        uid = hashlib.sha256(f"{platform}:{external_id}".encode()).hexdigest()
        self.con.execute("""
            INSERT INTO raw_mentions (id, platform, author, content, url, created_at)
            VALUES (?, ?, ?, ?, ?, ?)
            ON CONFLICT (id) DO NOTHING
        """, [uid, platform, author, content, url, created_at])
        return uid

3. Structured Gemini 1.5 Flash Evaluation

To eliminate hallucinations and avoid parsing regex out of freeform LLM completions, we leverage Google GenAI's native Pydantic schema validation. We use gemini-1.5-flash due to its sub-second latency and $0.075 per 1M tokens cost tier.

The Evaluation Schema

from pydantic import BaseModel, Field
from typing import List, Literal
import google.generativeai as genai
import os

genai.configure(api_key=os.environ["GEMINI_API_KEY"])

class SentimentEvaluation(BaseModel):
    polarity: float = Field(
        description="Polarity score strictly between -1.0 (extremely negative/hostile) and 1.0 (enthusiastic/positive)."
    )
    urgency: Literal["low", "medium", "high", "critical"] = Field(
        description="'critical' indicates data breaches, service downtime, or legal threats; 'high' indicates severe bugs or churn threats; 'medium' is regular feedback; 'low' is passive mention."
    )
    is_sarcastic: bool = Field(description="True if the statement implies the opposite of its literal words.")
    entities: List[str] = Field(description="List of specific products, competitor names, or people mentioned.")
    summary: str = Field(description="1-sentence technical digest of the user's issue or praise.")

Inference Function with Enforced JSON Schema

import json

def evaluate_mention(brand_name: str, text: str) -> SentimentEvaluation:
    prompt = f"""
    Analyze the following social mention referencing the brand: '{brand_name}'.
    Contextualize sarcasm, tech nuances, and developer sentiment.
    
    Content:
    """{text}"""
    """
    
    model = genai.GenerativeModel("gemini-1.5-flash")
    
    response = model.generate_content(
        prompt,
        generation_config=genai.GenerationConfig(
            response_mime_type="application/json",
            response_schema=SentimentEvaluation,
            temperature=0.1,
        ),
    )
    
    return SentimentEvaluation.model_validate_json(response.text)

4. Threshold Alerting & Webhook Routing

When a negative spike occurs (e.g., a critical authentication vulnerability drops on Hacker News), latency matters. The dispatcher inspects the structured output and fires immediate payloads to Slack, Discord, or an incident management endpoint like PagerDuty.

import httpx
import asyncio

SLACK_WEBHOOK_URL = os.environ.get("SLACK_WEBHOOK_URL")

async def dispatch_alert(eval_data: SentimentEvaluation, platform: str, url: str, content: str):
    # Alert trigger: high/critical urgency OR heavily negative sentiment
    if eval_data.urgency in ["high", "critical"] or eval_data.polarity <= -0.5:
        color = "#FF0000" if eval_data.urgency == "critical" else "#FFA500"
        
        payload = {
            "attachments": [
                {
                    "color": color,
                    "title": f"🚨 Brand Alert [{eval_data.urgency.upper()}] on {platform}",
                    "title_link": url,
                    "fields": [
                        {"title": "Summary", "value": eval_data.summary, "short": False},
                        {"title": "Polarity", "value": f"{eval_data.polarity:.2f}", "short": True},
                        {"title": "Sarcasm Detected", "value": str(eval_data.is_sarcastic), "short": True},
                        {"title": "Entities", "value": ", ".join(eval_data.entities) or "None", "short": True},
                    ],
                    "text": f"*Snippet:*
> {content[:280]}...",
                }
            ]
        }
        
        async with httpx.AsyncClient() as client:
            resp = await client.post(SLACK_WEBHOOK_URL, json=payload)
            resp.raise_for_status()

5. Deployment, Concurrency & Rate Limits

Running high-frequency pollers against varied APIs presents two main issues:

Rate Limit Exhaustion: Reddit restricts standard OAuth to 60 requests/minute. Gemini 1.5 Flash has a free-tier limit of 15 RPM and Tier-1 pay-as-you-go limit of 1,000 RPM.
Event Loop Starvation: Blocking HTTP calls freeze background listeners.

The Concurrency Pool Pattern

Use an asyncio.Queue paired with worker pools to guarantee your workers respect rate bounds:

async def analysis_worker(queue: asyncio.Queue, db: StorageManager, brand_name: str):
    while True:
        item = await queue.get()
        uid, platform, author, content, url = item
        try:
            # Non-blocking run for Gemini evaluation
            eval_res = await asyncio.to_thread(evaluate_mention, brand_name, content)
            
            # Save analytics to DuckDB
            db.con.execute("""
                INSERT INTO sentiment_results (id, polarity, urgency, is_sarcastic, entities, summary)
                VALUES (?, ?, ?, ?, ?, ?)
            """, [uid, eval_res.polarity, eval_res.urgency, eval_res.is_sarcastic, 
                  json.dumps(eval_res.entities), eval_res.summary])
            
            # Route Alerts
            await dispatch_alert(eval_res, platform, url, content)
            
        except Exception as e:
            print(f"[ERROR] Failed to process {uid}: {e}")
        finally:
            queue.task_done()

Analytical Daily Rollups via DuckDB

To view aggregated brand health over the past 24 hours without loading heavy Pandas workflows:

SELECT 
    date_trunc('hour', evaluated_at) as hour_bucket,
    AVG(polarity) as avg_sentiment,
    COUNT(CASE WHEN urgency IN ('high', 'critical') THEN 1 END) as critical_count,
    COUNT(*) as total_mentions
FROM sentiment_results
WHERE evaluated_at >= NOW() - INTERVAL '24 HOURS'
GROUP BY 1
ORDER BY 1 DESC;

6. Conclusion & Turnkey Template

With under 200 lines of modern Python, you can replace a legacy multi-thousand-dollar monitoring subscription with a real-time system that catches sarcasm, tags entities, writes to low-footprint local storage, and pings your on-call channel in real time.

You can manually implement this architecture using the snippets above, wire your own OAuth credentials, and maintain the worker pipelines yourself.

If you prefer to deploy a battle-tested, production-ready codebase immediately—complete with pre-configured connectors for Reddit, Bluesky, Hacker News, RSS feeds, an automated CLI dashboard, and native Docker Compose files:

Instant Access on Whop
Direct Download on Gumroad (Use promo code EARLYBIRD for 20% off)

Have questions about tuning the schema for specific B2B niche contexts? Drop a comment below!

ChatGPT, Claude, Gemini, or Cursor? Which AI Tool Is Your Go-To and Why?

Tue, 29 Sep 2026 08:04:49 +0000

ChatGPT, Claude, Gemini, or Cursor? Which AI Tool Is Your Go-To and Why?

Hey CodeLegion community! 💻

Whether you are debugging complex codebases, writing technical documentation, exploring new frameworks, or just trying to automate daily workflows, AI tools have become an essential part of the modern developer's toolkit.

With models and assistants constantly updating, everyone in tech seems to have their own preferred setup. We want to know: Which AI tool gets the most mileage in your stack, and why?

The Developer's Usual Suspects

Claude: Loved by engineers for its natural prose, ability to digest massive code repositories or specs in a single prompt, and clean code generation.
ChatGPT: The reliable all-rounder for architecture advice, algorithm troubleshooting, general problem-solving, and quick scripts.
Cursor / GitHub Copilot: Integrated directly into the IDE for real-time code completion, inline refactoring, and multi-file contextual edits.
Gemini: Great for real-time web search, large context windows, and tight integration across Google Workspace apps and cloud workflows.
Perplexity: The go-to search companion for looking up API documentation, library updates, and technical research with cited sources.

Join the Discussion!

We’d love to hear from the legion. Drop your thoughts in the comments below:

What is your primary AI tool for work or personal projects?
What technical task do you use it for most (coding, debugging, architecture, documentation)?
What is the one killer feature or model capability that keeps you using it?

Google confirmed Gemini accessed 3 live corporate systems during a red-teaming test

Tue, 22 Sep 2026 17:11:35 +0000

While headlines blamed "rogue AI," the actual culprit was a classic infrastructure failure: un-enforced network egress controls and domain collisions.

Here’s the TL;DR on what broke and why it’s happening across Anthropic, OpenAI, and Meta:

⚡ Key Takeaways:

The Root Cause: A test environment domain matched a live commercial entity, and egress traffic wasn't air-gapped.

Model Misalignment vs. Env Failure: Gemini stopped execution the moment it realized it crossed test boundaries. The model didn't fail—the sandbox did.

The Industry Pattern: Anthropic, OpenAI, and Meta have all suffered similar containment breaches during automated agent testing.

The Fix: Strict DEFAULT-DENY outbound network rules, synthetic credential scrubbing, and real-time egress anomaly monitoring.

👇 Read the full engineering deep-dive on The Flux Read:🔗
[https://www.thefluxread.com/2026/09/google-just-admitted-gemini-hacked.html]

The Stateless Inference Pipeline: Ephemeral Payloads and Quota Metadata

Wed, 27 May 2026 08:00:00 +0000

The Stateless Inference Pipeline: Ephemeral Payloads and Quota Metadata

POST /api/ai/chat is Pocket Analyst’s inference hop. The route header in app/api/ai/chat/route.ts states the contract plainly:

/**
 * Stateless: request payload (message, context, attachedContent) is used only
 * to build the LLM prompt and stream the response. No database write or cache
 * of the payload; only analytics/quota metadata are persisted.
 */

Stateless here means stateless with respect to the portfolio context string — not “the server never touches cloud.”

End-to-end flow (accurate)

Raw client corpus (trades / positions in memory)
  → buildPortfolioContext()     [client, Part 2]
  → bounded string in POST body
  → /api/ai/chat                [build prompt, stream out]
  → optional Firestore/KV quota + analytics metadata only

Full engineering record: docs/IP-TECHNICAL-MECHANISMS.md (patent-aligned mechanisms, CSV truncation rules, quote injection).

What may persist server-side

Data class	Typical store	Purpose
Portfolio `context` string	Not written to portfolio DB by this route	Ephemeral prompt input
Free-tier usage counters	Firestore and/or Vercel KV	Quota enforcement (`FREE_TIER_MONTHLY_LIMIT`)
Auth / tier resolution	Firebase Admin	Paid vs free model routing

Paid tiers skip monthly caps; free tier enforces limits — still not a ledger warehouse.

Model routing and attachments

The route tries Gemini when GOOGLE_GENERATIVE_AI_API_KEY is set, with OpenAI fallback. MAX_ATTACHED_CONTENT_LENGTH caps server-side attachment size (frontend also caps).

Attachments are a deliberate second boundary: if the user uploads file text, that is explicit — distinct from the default sanitized snapshot path.

Streaming

We use the Vercel AI SDK (streamText) for token streaming — UX requirement and operational standard in this codebase (CLAUDE.md). The response is generated once per request; there is no server-side conversation memory of portfolio rows in this handler.

Procurement questions this answers

Can you prove non-retention of portfolio payload? → Route comment + IP doc + absence of write calls on context.
Do you still have cloud? → Yes: Firebase, KV, LLM APIs, Vercel — calibrated honesty (Part 4).
What does the model see? → Bounded aggregate + user message + optional attachment + server quotes — not “nothing.”

Part 3 of Sovereign Ingestion & Stateless Inference.

Read the full Sovereign Intelligence book, explore Open Portfolio, or try Pocket Portfolio.

Antigravity CLI First Impressions: Fast, Rough, and Not Ready

Thu, 21 May 2026 11:07:17 +0000

Google has officially replaced Gemini CLI with the new Antigravity CLI and launched it alongside Gemini 3.5 Flash, which became the default model for the new CLI experience. That made the launch more than a simple rebrand: it was also the first real chance to see whether Google’s new default coding-agent stack actually felt better in practice

To test that, I ran Ship Bench, the real-coding-workflow benchmark I built to evaluate how models and coding agents behave in practical development tasks, rather than toy prompts or isolated code snippets. This was not a full benchmark write-up; it was a quick first-pass meant to capture what it felt like to use Antigravity CLI as a working developer tool while exercising a realistic repo workflow through Ship Bench.

What I tested

I used Antigravity CLI on Windows in the context of a Ship Bench run, which meant the CLI was being pushed through a practical coding loop rather than a curated demo. The goal was not just to test whether the agent could answer prompts, but whether it could survive the kind of environment, permissions, command execution, and iteration flow that real coding work demands.

I could have switched to Gemini Pro, but I intentionally stayed on Gemini 3.5 Flash, as the default model I wanted to see whether its promised speed and quota efficiency would make it the better everyday option. In other words, the test was really: Can it extend my usage quote over using a larger/pro model with the same quality?

First-run impressions

The first impression was mixed. Gemini 3.5 Flash is genuinely fast, and the agent feels quick and responsive, but the surrounding CLI experience was rough enough that it overshadowed most of the upside.

On the first development iteration, the model decided it wanted a different (older) Node version and used nvm to install an older one. After that, it seemed to lose track of Node on PATH entirely. It tried to recover, failed to reload the environment cleanly, then started searching the file system for node.exe and dynamically re-adding that location to PATH on each command run. That behavior appears to be what triggered repeated permission prompts on every command. A pretty miserable experience. Once the terminal and CLI were restarted, that specific problem cleared up and normal command execution returned.

That first issue felt like a bad transient state rather than the main product problem. The more important issue showed up in a more normal run: Antigravity CLI would not remember conversation-scoped permission grants, even after they had already been approved. That made the workflow feel fragmented and repetitive, because the tool kept asking for approval where the session context suggested it should already know the answer. Frustrating.

The handling of background commands also felt awkward. When running npm work in the background, the CLI shifted into a wait-timer style interaction instead of just naturally waiting on the task, which made the orchestration feel more mechanical than smooth. I suppose it could end up beneficial when it decides to run parallel tool calls.

I also hit the same class of Windows terminal issues other users have been discussing, including hanging or inconsistent command execution behavior in terminal sessions in addition to terminal resize issues. Basic expectations, really. On Windows especially, the CLI still feels unstable enough that the shell layer becomes part of the story rather than disappearing into the background.

Flash versus the CLI

One important distinction is that not every failure belonged to the CLI itself. For example, failing to add a .gitignore file on the first run feels more like a Gemini 3.5 Flash planning/execution miss than a shell-wrapper problem.

In that sense, the experience split into two separate judgments. Gemini 3.5 Flash felt fast and promising as a coding model, but Antigravity CLI felt rough as the environment wrapped around it. The difficult part is that, from a user perspective, those layers blur together fast when the default workflow is what you are actually evaluating.

Quota and value

The quota behavior ended up being the biggest practical negative. I chose to test Gemini 3.5 Flash specifically because it was the new default and because one of the appealing ideas behind Flash was that it could extend usable quota while still feeling fast enough for real work. Instead, I burned through quota shockingly quickly.

In practice, I could not get through even two meaningful iterations before hitting quota limits, and at one point the interface reported about 20% quota remaining while still refusing to continue. That mismatch made the product feel unreliable in exactly the area where a coding agent has to be predictable. In contrast, I was able to complete a seven iteration run with Claude Code Sonnet within its 5-hour quota, which made Antigravity’s current usage story feel much worse by comparison.

That is probably the biggest reason this left such a negative impression. Google AI Pro had started to look like one of the better-value options in the coding-agent space, but if the default Antigravity CLI plus Gemini 3.5 Flash path burns quota this fast while also failing to carry work forward smoothly, the value proposition drops hard.

Recommendation

Right now, the fairest read is that Antigravity CLI ships with a promising engine but an unstable developer experience. Gemini 3.5 Flash is fast enough to make the launch interesting, but the combination of permission persistence problems, Windows terminal roughness, odd environment recovery behavior, and unexpectedly harsh quota limits makes the overall package hard to recommend.

For a quick Ship Bench-driven first impression, this lands as a strong “not recommended” for me. The model may be improving, but the CLI needs to stabilize before it feels like a real replacement for the more mature Gemini CLI experience.

From Chatbots to Coworkers: What Google Cloud Next '26 Means for Developers

Mon, 27 Apr 2026 10:26:55 +0000

Originally published on dev.to.

A developer's breakdown of everything that matters from the Google Cloud Next '26 keynote and what to build with it next.

For the last two years, every AI keynote has felt like a magic show "look at this thing that can write a poem."

Google Cloud Next '26 was different.

The magic show is over.

The actual machinery is here.

Thomas Kurian and Sundar Pichai opened the keynote with a single, quietly disruptive idea: we're done with chatbots that talk. The new era is about agents that do: systems with persistent reasoning and autonomous execution that can hold context for days, plan multi-step workflows, and verify their own work.

2024 and 2025 asked, "Can we build an agent?", 2026 asks, "How do we manage thousands of them?"
For developers especially those of us building at the intersection of frontend, data, and distributed systems this is the most consequential Next in years. Here's what actually shipped, what it means, and where to start.

The Agentic Enterprise Blueprint

Kurian framed the entire conference around one concept: The Agentic Enterprise. The pitch is that the org chart of the future doesn't just have humans it has digital teammates working alongside them, and every employee becomes a builder who orchestrates a swarm of agents instead of executing tasks manually.

The strategy rests on two ideas:

Persistent reasoning: Unlike a chatbot that forgets you the moment you close the tab, agents maintain state across days. They can pause, wait for an external trigger, resume, and finish the job like a human colleague would.
Owning the full stack: Custom silicon (TPUs), the data layer (BigQuery), and the UX (Workspace) all built to work together. Kurian's not-so-subtle jab at competitors: they "hand you the pieces, not the platform."

Whether you buy that framing or not, the takeaway is clear Google is betting that vertically integrated infrastructure wins the agent era. And the rest of the keynote was them showing receipts.

Gemini Enterprise Agent Platform (The Vertex AI Rebrand)

The biggest rebrand of the event: Vertex AI is now the Gemini Enterprise Agent Platform. It's no longer a model garden it's a unified environment for the entire agent lifecycle, from prototype to production to post-deployment monitoring.

The core features that make up the platform:

Agent Studio: A low-code, visual builder inside Workspace. Defines agent goals in natural language, wire up tools, and ship.
Agent Development Kit (ADK) v1.0: The pro-code framework for the rest of us. Supports Python, JavaScript, Java, and Go, and lets you build graph-based agent networks (think LangGraph, but native).
Agent Identity: Every agent gets a unique cryptographic ID. Every action it takes is auditable. This is huge for compliance finally, a real answer to "Which agent did that, and why?"
Agent Gateway: Air traffic control for your agent fleet. Enforces policy, manages traffic, and uses Model Armor to block prompt injection attacks at the edge.
A2A (Agent-to-Agent) Protocol: A standardized handshake that lets a Google-based agent securely delegate tasks to a Salesforce or SAP agent. Cross-vendor interoperability, finally.
Agent Runtime: A re-engineered execution environment built for long-running agents. Your agent can fire off a task, wait three days for an external API to respond, and pick up exactly where it left off.
Agent Simulation & Evaluation: Stress-test your agent against thousands of simulated user interactions before it ever sees production. Catches logic drift before your users do.

What's Actually Shipping

If Day 1 sold the strategy, Day 2 showed the developer loop underneath it. The framing: build an agent system that plans a marathon for 10,000 runners through the Las Vegas Strip, using three agents — a planner (generates routes), an evaluator (scores them against constraints), and a simulator (runs the route end-to-end). The entire codebase and every demo were open-sourced as a GitHub repo plus Codelabs. The platform was anchored around four pillars and each pillar got its own demo segment.

️️ Build

ADK (Agent Development Kit): the code-first framework, supporting Python, JavaScript, Java, and Go, with a new graph-based runtime for defining how agents collaborate.
Agent Studio: the low-code counterpart. Define agent goals in natural language, wire up tools, publish.
Managed MCP: Google now hosts the Model Context Protocol layer, eliminating a week of self-hosting plumbing.
Agent Registry: described as "the DNS of your internet of agents." Auto-indexes every agent deployed to Agent Runtime, making them discoverable and governable.
Agent Marketplace: third-party agents from Atlassian, Box, Lovable, Oracle, ServiceNow, Workday, and more, deployable directly from Gemini Enterprise.
Model Garden: explicitly supports Claude, Gemini 3.1 Pro, Gemini 3.1 Flash, and others. Pick your model, swap when needed.

Scale

Serverless Agent Runtime: handles long-running state across days. Agents pause, wait for an external trigger, and resume without losing context.
A2A (Agent-to-Agent) Protocol: the cross-vendor handshake. Created by Google, donated to the Linux Foundation. A Google agent can hand work to a Salesforce or SAP agent without brittle API code.
A2UI (Agent-to-User Interface): an open standard letting agents generate dynamic UI components instead of returning plain text. The marathon simulator's UI (Angular + 3D rendering of the Las Vegas Strip) was assembled live by the agent itself, not hardcoded.

The evaluation layer is now first-class. A separate model as a judge scores outputs across deterministic criteria (a marathon is exactly 26 miles 385 yards / 42.195 km) and non-deterministic ones (community impact, route quality). Agents auto-generate their evaluation UIs from the schema of their own outputs the path from "fragile, unpredictable agentic loops" to "a rigorously evaluated network of experts."

Govern

The framing here was sharp: stop telling developers to "shift left" (own everything earlier) and start letting them "shift down" push the responsibility into the platform layer.

Agent Identity: every agent gets a unique, immutable cryptographic credential. Every action is auditable back to a specific agent instance.
Agent Gateway: air traffic control for the agent fleet. Understands MCP and A2A protocols. Uses IAM policies to scope which sources can invoke agent actions.
Agent Policies: configurable guardrails. An agent permitted to read from BigQuery but blocked from triggering spend over a threshold.
Model Armor: inline protection against prompt injection, tool poisoning, and sensitive data leakage at the gateway layer.

Optimize

The end-to-end debugging story for when an agent breaks in production:

Agent Runtime trace view: surfaces exactly where the reasoning chain or tool call failed.
Gemini Cloud Assist Investigation: takes a natural-language query and explores logs and events to surface the failing component down to a specific line.
Antigravity IDE: powered by Gemini 3, connected via MCP. Proposes parameter-level remediations. In the demo: a missing token_threshold on the event-compaction config that was silently truncating the agent's working memory.
Wiz Green Agent inside Claude Code with Opus: Wiz now scans both agent code and infrastructure, and the same remediation surface runs inside Anthropic's IDE on Anthropic's model. An explicit multi-vendor signal: security tooling travels with the developer, regardless of stack.

What it means for you

Day 1 sold the agentic enterprise. Day 2 laid out the loop you'll actually live in: build → scale → govern → optimize. Three things to actually act on:

The evaluation layer is the part most teams will sleep on and regret. Judge models, deterministic + non-deterministic checks, auto-generated eval UIs: this is where agentic systems silently fail today, and it's now baked in.
A2A and A2UI are open standards, not Google-only. The Linux Foundation handoff matters. Don't dismiss them as vendor lock-in.
Antigravity is the bet to watch. It's Google's claim on what "agentic developer experience" means in 2026 and the multi-vendor Wiz/Claude Code integration shows the surface area is intentionally portable.

The AI Hypercomputer: 8th-Gen TPUs

To run millions of persistent agents in production, you need silicon designed for the workload. Google's answer is the 8th-generation TPU and crucially, it's a dual-chip strategy that splits training and inference into purpose-built hardware. This is Google explicitly attacking the "memory wall" that's been bottlenecking large models.

What it means for you: Cloud developers now have a dedicated inference engine in the TPU 8i. The economics of running a complex, multi-turn agent for every single user in your app just got real. The "one agent per user" pattern was a fantasy in 2024 at these unit costs, it becomes a default architecture.

Agentic Data Cloud: From Passive Storage to System of Action

"Reasoning without context is just a guess" that's how Karthik Narain, Google Cloud's Chief Product and Business Officer, framed the thesis behind the Agentic Data Cloud, which reimagines data as something agents act on, not just query.

Three pieces matter most:

Knowledge Catalog: Replaces traditional metadata catalogs. It auto-maps the business meaning of data across your entire estate (Google Docs, Slack, SQL warehouses, the lot). Your agents now understand that "ARR" in finance means the same thing as "Annual Recurring Revenue" in your CRM.
Memory Bank: Long-term memory for agents. Where chat sessions used to forget you in five minutes, Memory Bank persists user preferences and project history across months of interaction.
Managed MCP: You no longer host your own Model Context Protocol servers. Google now manages the connective tissue between Gemini and your databases, which kills a whole class of plumbing work.

Agentic Defense: The Wiz Integration Goes Live

With the $32 billion Wiz acquisition fully closed, Google rolled out a "Cyberforce" of defensive agents. The pitch: stop reacting to alerts, start hunting threats autonomously.

Threat Hunting Agent: Proactively scans for novel attack patterns that signature-based firewalls miss.
Detection Engineering Agent: Writes and deploys new security rules in real time as threats evolve. The rule that catches tomorrow's attack didn't exist yesterday.
Wiz "Red Agent": An autonomous penetration tester that constantly probes your cloud infrastructure for unlocked doors before real attackers find them.

The Agentic Taskforce: Companies Already Shipping

The keynote closed with proof points companies actually getting ROI from agents in production right now. The pattern across all of them: agents handling the long-tail repetitive work, humans focusing on judgment calls. A few standouts worth zooming in on:

KPMG's Tax Swarms are the clearest A2A protocol use case in the wild; their tax agent talks directly to a client's audit agent.
Virgin Voyages going from 6-hour rebookings to 11 minutes is the clearest "Agent Runtime + long-running state" example.
Goldman Sachs querying 10,000+ page filings in minutes is what the Knowledge Catalog actually unlocks at enterprise scale.
Walmart and Bosch prove agents work at the edge — store floors and factory floors, not just data centers.

So What Should You Actually Do With This?

If you take one thing from Next '26, take this: the agent era isn't a future bet, it's a current one. The infrastructure is shipping, the protocols are standardizing, and Fortune 500s are already in production.

Concretely, here's where to start depending on your stack:

Frontend devs: Play with Agent Studio. The low-code builder is the fastest way to feel what an agentic UX is even supposed to look like.
Backend / data folks: The Knowledge Catalog and Memory Bank are the most underrated announcements. Try wiring an agent to your own data with Managed MCP and skip a month of plumbing.
Infra / platform engineers: Watch the TPU 8i pricing closely. The economics of "an agent per user" change your architecture decisions for the next two years.
Security teams: Don't wait. Threat Hunting and Red Agent are the kind of tools your blue team will quietly start depending on by Q3.

The chatbot era taught us how to prompt. The agent era is going to teach us how to delegate. The developers who figure that out first are going to look like wizards by the end of 2026.

If you watched the keynote too, what stood out for you? Drop a comment especially if you've started prototyping with the ADK. I'm curious what's actually working vs. what's still demo-ware.

Prompt Grounding in a Stateless World

Wed, 22 Apr 2026 11:16:00 +0000

Prompt Grounding in a Stateless World

When we say “CFA-grade” in product language, we mean three engineering layers: domain-scoped system text, client portfolio summary, and server-injected live quotes—plus an optional attachment lane for paid users.

Layer 1 — `SYSTEM_PROMPT` (persona + guardrails)

In app/api/ai/chat/route.ts, SYSTEM_PROMPT constrains the assistant to finance, tells it to use portfolio context when present, to use “Current quote data” when injected, and to treat “File the user included” as authoritative for that turn. It also nudges 1–3 markdown citations to reputable sources when helpful.

This is how we steer the model without storing conversation state server-side.

Layer 2 — Portfolio context block

The handler builds:

const contextBlock = context
  ? `\n\nPortfolio context:\n${context}`
  : '\n\n(No portfolio context provided.)';

context is the entire output of buildPortfolioContext (Part 2–3). So grounding for holdings is exactly what the client compiled — not a server-side join against a portfolios table.

Layer 3 — Live quote injection (`extractSymbolHints`)

The route parses the user message for tickers and known names (NAME_TO_TICKER), caps symbols, calls internal /api/quote, and appends a quote block into the system string. That gives price truth without the user pasting screenshots.

Layer 4 — Attachments (paid)

const attachedBlock = attachedContent
  ? `\n\nFile the user included (use this):\n${attachedContent}`
  : '';
const systemPrompt = SYSTEM_PROMPT + contextBlock + quoteBlock + attachedBlock;

MAX_ATTACHED_CONTENT_LENGTH = 60_000 on the server caps abuse. Different privacy contract than default top-N context.

Provider routing

Comments in route.ts: Gemini preferred when GOOGLE_GENERATIVE_AI_API_KEY is set (gemini-1.5-flash free tier, gemini-1.5-pro paid); OpenAI fallback when configured or when Gemini errors.

Why 10k CSV rows never hit the model (default path)

Compaction happens client-side before the request. The model sees tens of lines, not tens of thousands.

Part 6 of Sovereign Engineering.

Read the full Sovereign Intelligence book or try the app.

The Anthology of a Creative Developer: A 2026 Portfolio

Mon, 13 Apr 2026 18:13:28 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI (just check my github, not for prizes )

The Prologue: Beyond the "Sectioned Resume"

Most portfolios feel like a list of ingredients. For 2026, I wanted mine to be the complete meal.

I’m Nitish Kumar, an undergraduate engineering student and creative developer. I’ve always felt that code is just another way of storytelling—so I ditched the typical "Hero-About-Projects" grid. Instead, I built a narrative experience that reflects how I think, build, and observe the world.

The Gallery

I built this to be "authored"—a stroll through a digital gallery rather than a scroll through a resume.

Explore the Story: https://nitishkr.fun

The Craft (How I Built It)

If this portfolio were a book, here is how I bound the pages:

The Technical Spine

Next.js (App Router): The foundation that holds the chapters together.
TypeScript: My editor, ensuring every "sentence" (and variable) makes sense.
GSAP: The cinematography—adding subtle, intentional motion that guides the eye.
Tailwind CSS: For the editorial aesthetic and spacing.
Cloud Run: My printing press, keeping everything fast and accessible.

The Editorial Vision

I treated the design like a high-end magazine. Each section is a chapter:

Identity: The "Who" and the mindset.
The Workshop: Skills and tools as a craftsman’s kit.
The Lab: Projects as experiments, not just finished products.
The Lens: Using photography as a reflection of how I observe UI/UX in the real world.

Google AI: The Creative Director

Google AI wasn't a "generator" for me; it was a thinking partner. I used it to:

Refine the Copy: Helping me transition from dry technical descriptions to narrative-driven prose.
Accessibility Review: Ensuring the "story" remains readable for everyone.
Logic Soundboarding: Using AI to brainstorm the best way to structure a chapter-based layout.

The "Director's Cut" (What I'm Proud Of)

Story-Driven Flow: The site feels like a single, continuous conversation.
Intentional Dark Mode: Designed from the ground up to feel like a premium "night-time" reading experience.
The Power of Restraint: Knowing when to stop adding features and start refining the white space.
Photography Integration: My photos aren't just "assets"—they are windows into my perspective as a designer.

Closing Thoughts

This portfolio is my way of proving that engineering is an art form. It’s about more than just shipping code; it’s about crafting experiences that linger.

Thanks for checking it out, and Happy New Year!

Let's connect!

Customizing Azure Cloud Shell for Cross Cloud Development

Tue, 07 Apr 2026 13:46:11 +0000

title: Customizing Azure Cloud Shell for Cross Cloud Development
published: true
series: Azure
date: 2026-03-11 15:33:50 UTC
tags: googlecloudplatform,linux,azurecloudshell,geminicli

canonical_url: https://xbill999.medium.com/customizing-azure-cloud-shell-for-cross-cloud-development-5af464de14ab

This article covers installing and Running Gemini CLI cross-cloud. The Azure Cloud Shell provides a basic Linux environment that can support running Gemini CLI.

What is Gemini CLI?

The Gemini CLI is an open-source, terminal-based AI agent from Google that allows developers to interact directly with Gemini models, such as Gemini 2.5 Pro, for coding, content creation, and workflow automation. It supports file operations, shell commands, and connects to external tools via the Model Context Protocol (MCP).

The full details on Gemini CLI are available here:

Build, debug & deploy with AI

Azure Cloud Shell

Azure Cloud Shell is a browser-based, authenticated terminal for managing Azure resources, accessible directly through the Azure portal, shell.azure.com, or the mobile app. It provides a preconfigured environment with Bash or PowerShell, eliminating local installation of tools. It runs on a temporary, secure, Linux-based host.

The full background information on the Cloud Shell is here:

https://azure.microsoft.com/en-us/get-started/azure-portal/cloud-shell

More information is available here:

Get started with Azure Cloud Shell

Why would I want Gemini CLI on Azure? Isn’t that a Google Thing?

Yes- Gemini CLI leverages the Google Cloud console and Gemini models but it is also open source and platform agnostic. Many applications are already cross-cloud so this enables familiar tools to be run natively on Microsoft Azure.

Activating Azure CloudShell

The Azure CloudShell comes preinstalled on all Azure Accounts.

To access the shell — click the Terminal Icon in the upper right hand corner of the console:

Then activate the full shell:

Note- the disk space in the environment is limited to 5GB- but this is sufficient for Gemini CLI, Google Cloud Tools, and some customization.

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

Verifying Node.js in Azure Cloud Shell

The version of Node.js is verified that it is recent enough to support Gemini CLI:

william@Azure:~$ node --version
v25.8.1
william@Azure:~$ npm --version
11.11.0
william@Azure:~$

Gemini CLI Installation

You can then download the Gemini CLI :

npm install -g @google/gemini-cli

You will see the log messages:

william@Azure:~$ npm install -g @google/gemini-cli
npm warn deprecated prebuild-install@7.1.3: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
npm warn deprecated node-domexception@1.0.0: Use your platform's native DOMException instead
npm warn deprecated glob@10.5.0: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me

added 618 packages in 48s

173 packages are looking for funding
  run `npm fund` for details
william@Azure:~$

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

Authentication

Several authentication options are available. To use an existing Code Assist licence — authenticate with a Google Account:

> /auth                                                                                                                                                        
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ │
│ ? Get started │
│ │
│ How would you like to authenticate for this project? │
│ │
│ ● 1. Login with Google │
│ 2. Use Gemini API Key │
│ 3. Vertex AI │
│ │
│ (Use Enter to select) │
│ │
│ Terms of Services and Privacy Notice for Gemini CLI │
│ │
│ https://geminicli.com/docs/resources/tos-privacy/ │
│ │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Then set the GOOGLE_CLOUD_PROJECT to a valid project setup on the Google Cloud console:

~ $ export GOOGLE_CLOUD_PROJECT=comglitn
~ $

Other options include Google Cloud API Key that can be generated directly from the Google Cloud Console.

Using Gemini CLI on Azure Cloud Shell

Once installed- Gemini CLI has direct access to the Cloud Shell environment:

Logged in with Google: xbill@glitnir.com /auth
Plan: Gemini Code Assist Standard

✦ Your Azure project information is as follows:

   - Subscription Name: Azure subscription 1
   - Subscription ID: 3db3ce66-50b6-4d11-91ef-5950cf4039ed
   - Tenant ID: 40482c55-d00d-4c6d-8903-643d76a74b9c
   - Environment: AzureCloud
   - User: live.com#xbill@glitnir.com

  Active Resource Groups:
   - cloud-shell-storage-eastus (eastus)
   - NetworkWatcherRG (eastus)
   - vm (eastus)

  Project Metadata:
   - Repository: github.com/xbill9/gemini-cli-azure (https://github.com/xbill9/gemini-cli-azure)
   - Google Cloud Project ID: comglitn (from project_id.txt)

and Azure operations can be performed directly from Gemini CLI:

 > list azure vms using the az command                                                                                                                          
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
✦ I'll list your Azure Virtual Machines using the az command.

╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Shell az vm list -d -o table [current working directory /home/william] (List all Azure Virtual Machines in the current subscription with detailed in… │
│ │
│ Name ResourceGroup PowerState PublicIps Fqdns Location │
│ --------- --------------- -------------- ------------- ------- ---------- │
│ azure-new VM VM deallocated 20.124.121.35 eastus │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ You have one Azure Virtual Machine:

   - Name: azure-new
   - Resource Group: VM
   - Power State: VM deallocated
   - Public IP: 20.124.121.35
   - Location: eastus

Installing Google Cloud Tools

To simplify working with Google Cloud — install the Google Cloud Tools:

https://docs.cloud.google.com/sdk/docs/install-sdk

Once the installation is completed — you can verify the setup:

william@Azure:~$ gcloud auth list
  Credentialed Accounts
ACTIVE ACCOUNT
* xbill@glitnir.com

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

william@Azure:~$ gcloud config list
[compute]
region = us-west2
zone = us-west2-a
[core]
account = xbill@glitnir.com
disable_usage_reporting = False
project = comglitn

Your active configuration is: [default]
[environment: Development]
william@Azure:~$

Installing Azure Customized GEMINI.md

A sample GitHub repo contains tools for working with Gemini CLI on Azure. This repo is available here:

git clone https://gitHub.com/xbill9/gemini-cli-azure

A sample GEMINI.md customized for the Azure environment is provided in the repo:

This is a multi linux git repo hosted at:

github.com/xbill9/gemini-cli-azure

You are a cross platform developer working with 
Microsoft Azure and Google Cloud

You can use the Azure CLI :
https://learn.microsoft.com/en-us/cli/azure/install-azure-cli
https://learn.microsoft.com/en-us/cli/azure/
https://learn.microsoft.com/en-us/cli/azure/reference

https://learn.microsoft.com/en-us/cli/azure/install-azure-cli-linux?view=azure-cli-latest&pivots=apt

## Azure CLI Tools

You can use the Azure CLI to manage resources across Azure Storage, Virtual Machines, and other services.

- **List Resource Groups** : `az group list -o table`
- **List Storage Accounts** : `az storage account list -o table`
- **List Virtual Machines** : `az vm list -d -o table`

### Azure Update Script

- `azure-update`: This script is specifically for Azure Linux environments. It updates all packages and ensures necessary libraries are installed.

## Automation Scripts

This repository contains scripts for updating various Linux environments and tools:

- `linux-update`: Detects OS (Debian/Ubuntu/Azure Linux) and runs the corresponding update scripts.
- `azure-update`: Updates Azure Linux packages and installs necessary dependencies.
- `debian-update`: Updates Debian/Ubuntu packages and installs `git`.
- `gemini-update`: Updates the `@google/gemini-cli` via npm and checks versions of Node.js and Gemini.
- `nvm-update`: Installs NVM (Node Version Manager) and Node.js version 25.

Perform Cross Cloud Operations

Now that all the building blocks are in place- the Azure Cloud Shell has all the tools to have visibility into both clouds. Gemini CLI can be used directly with the gcloud utility running on Azure:

william@Azure:~/gemini-cli-azure$ gemini

  ▝▜▄ Gemini CLI v0.33.0
    ▝▜▄
   ▗▟▀ Logged in with Google /auth
  ▝▀ Gemini Code Assist Standard /upgrade

Tips for getting started:
1. /help for more information
2. Ask coding questions, edit code or run commands
3. Be specific for the best results
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
 > summarize my google cloud project with the gcloud tools                                                                                                      
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄

✦ Based on the gcloud tools, here is a summary of your active Google Cloud project:

  Project Overview
   - Project Name: glitnir
   - Project ID: comglitn
   - Project Number: 1056842563084
   - Status: ACTIVE (Created: Aug 31, 2014)
   - Key Labels: firebase: enabled, generative-language: enabled.

Summary

Gemini CLI was downloaded and tested from the Azure Cloud Shell. This is a complete fully working version of Gemini CLI with all the standard features like extensions, agent skills, and a familiar interface. Then, Gemini CLI was used to perform Azure native operations using the built-in tooling. Finally the Google Cloud Tools were downoaded and installed. This is a first step to enabling cross platform projects with both Google Cloud and Azure.

Meeting you where you are at: Gemini CLI on AWS CloudShell

Tue, 07 Apr 2026 13:45:26 +0000

title: Meeting you where you are at: Gemini CLI on AWS CloudShell
published: true
series: AWS
date: 2026-03-04 16:43:22 UTC
tags: googlecloudplatform,aws,awscloudshell,geminicli

canonical_url: https://aws.plainenglish.io/meeting-you-where-you-are-at-gemini-cli-on-aws-cloudshell-4b95bf379a26

This article covers installing and Running Gemini CLI cross-cloud. The Amazon Cloud Shell provides a basic Linux environment that can support running Gemini CLI.

What is Gemini CLI?

The full details on Gemini CLI are available here:

Build, debug & deploy with AI

Amazon Cloud Shell

AWS CloudShell is a browser-based, pre-authenticated terminal that allows users to securely manage, explore, and interact with AWS resources directly from the AWS Management Console. It comes pre-installed with the AWS CLI, popular programming languages (Python, Node.js), and developer tools, removing the need for local configuration.

The full background information on the Cloud Shell is here:

Browser-based Shell - AWS CloudShell - AWS

Why would I want Gemini CLI on AWS? Isn’t that a Google Thing?

Activating Amazon CloudShell

The AWS CloudShell comes preinstalled on all AWS Accounts.

To access the shell— click the Terminal Icon in the upper right hand corner of the console:

Then activate the full shell:

Note- the disk space in the environment is limited to 1GB.

Verifying Node.js in AWS Cloud Shell

The version of Node.js is verified that it is recent enough to support Gemini CLI:

~ $ npm --version
10.8.2
~ $ node --version
v20.20.0

Gemini CLI Installation

You can then download the Gemini CLI :

sudo npm install -g @google/gemini-cli

You will see the log messages:

npm warn deprecated prebuild-install@7.1.3: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
npm warn deprecated node-domexception@1.0.0: Use your platform's native DOMException instead
npm warn deprecated glob@10.5.0: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me

added 624 packages in 37s

175 packages are looking for funding
  run `npm fund` for details
npm notice
npm notice New major version of npm available! 10.8.2 -> 11.11.0
npm notice Changelog: https://github.com/npm/cli/releases/tag/v11.11.0
npm notice To update run: npm install -g npm@11.11.0
npm notice
~ $

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

Then you will get full access to the CLI:

Authentication

Several authentication options are available. To use an existing Code Assist licence — authenticate with a Google Account:

Then set the GOOGLE_CLOUD_PROJECT to a valid project setup on the Google Cloud console:

~ $ export GOOGLE_CLOUD_PROJECT=comglitn
~ $

Other options include Google Cloud API Key that can be generated directly from the Google Cloud Console.

Using Gemini CLI on AWS

Once installed- Gemini CLI has direct access to the Cloud Shell environment:

Logged in with Google: xbill@glitnir.com /auth
Plan: Gemini Code Assist Standard
Tips for getting started:
1. Ask questions, edit files, or run commands.
2. Be specific for the best results.
3. Create GEMINI.md files to customize your interactions with Gemini.
4. /help for more information.
 > what does the aws command line tool do?
✦ The AWS Command Line Interface (CLI) is a unified tool that allows you to manage and automate your Amazon Web Services (AWS) resources directly from your terminal.

  Core Functions
   * Service Management: Control almost all AWS services (S3, EC2, Lambda, IAM, etc.) using commands instead of the web-based Management Console.
   * Automation & Scripting: Incorporate AWS operations into shell scripts (Bash, PowerShell, Zsh) to automate repetitive tasks like backups, infrastructure deployment,
     or scaling.
   * Resource Manipulation: Perform actions such as uploading/downloading files from S3 buckets, starting/stopping EC2 instances, and managing security credentials.
   * Direct API Access: It acts as a wrapper around the AWS SDKs, providing a direct way to interact with AWS public APIs.

  Example Commands
   * aws s3 ls: List your S3 buckets.
   * aws ec2 describe-instances: View details about your virtual servers.
   * aws configure: Set up your access keys and default region.

and AWS operations can be performed directly from Gemini CLI:


 > aws s3 ls
✦ I will check if the AWS CLI is installed and then attempt to list your S3 buckets.

╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ Action Required │
│ │
│ ? Shell aws --version && aws s3 ls [current working directory /home/cloudshell-user] (Check for AWS CLI installation and list S3 buckets.) │
│ │
│ aws --version && aws s3 ls │
│ Allow execution of: 'aws, aws'? │
│ │
│ 1. Allow once │
│ ● 2. Allow for this session │
│ 3. No, suggest changes (esc) │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

with the results returned:

✦ I will check if the AWS CLI is installed and then attempt to list your S3 buckets.

╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Shell aws --version && aws s3 ls [current working directory /home/cloudshell-user] (Check for AWS CLI installation and list S3 buckets.) │
│ │
│ aws-cli/2.33.30 Python/3.13.11 Linux/6.1.161-183.298.amzn2023.x86_64 exec-env/CloudShell exe/x86_64.amzn.2023 │
│ 2020-07-03 04:30:32 gitnir1 │
│ 2026-02-01 10:31:45 glitnir │
│ 2020-07-08 13:25:09 xbill99 │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ The AWS CLI is installed (version 2.33.30) and returned the following S3 buckets:

   - gitnir1 (Created: 2020-07-03)
   - glitnir (Created: 2026-02-01)
   - xbill99 (Created: 2020-07-08)

Session Results

Because the Gemini CLI Installation is the same across environments- all session information is consistent:

╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ │
│ Agent powering down. Goodbye! │
│ │
│ Interaction Summary │
│ Session ID: bf164e83-6373-458a-8ca3-91b5bdbf1fe3 │
│ Tool Calls: 3 ( ✓ 2 x 1 ) │
│ Success Rate: 66.7% │
│ User Agreement: 100.0% (3 reviewed) │
│ │
│ Performance │
│ Wall Time: 8m 53s │
│ Agent Active: 42.0s │
│ » API Time: 27.6s (65.6%) │
│ » Tool Time: 14.4s (34.4%) │
│ │
│ Model Usage │
│ Model Reqs Input Tokens Cache Reads Output Tokens │
│ ──────────────────────────────────────────────────────────────────────────── │
│ gemini-2.5-flash-lite 4 5,109 0 196 │
│ gemini-3-flash-preview 6 8,126 31,994 479 │
│ │
│ Savings Highlight: 31,994 (70.7%) of input tokens were served from the cache, reducing costs. │
│ │
│ Tip: Resume a previous session using gemini --resume or /resume │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

Summary

Gemini CLI was downloaded and tested from the AWS Cloud Shell. This is a complete fully working version of Gemini CLI with all the standard features like extensions, agent skills, and a familiar interface. Then, Gemini CLI was used to perform AWS native operations using the built-in AWS tooling. This is a first step to enabling cross platform projects with both Google Cloud and AWS.

Building DevTo-MCP: Bridging Forem API and AI Assistants with Google Gemini

Fri, 27 Mar 2026 14:18:37 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

As software developers, DEV Community (dev.to) and the wider Forem ecosystem have increasingly become our digital home. It's the place we go for "React best practices", solutions to obscure bugs, and career advice. But as our workflows become more tightly integrated with AI assistants, a gap has emerged: why can't our AI tools natively interact with this vibrant community?

Why couldn't I tell my AI assistant to "list popular Rust articles on DEV," or "take this markdown draft and publish it directly to my DEV account"?

To solve this, I built DevTo-MCP. It's an open-source Model Context Protocol (MCP) server that acts as a secure, type-safe bridge between the Forem API and AI assistants. And throughout this journey of architectural design, debugging, and implementation, Google Gemini was my constant pair-programming companion.

What I Built with Google Gemini

DevTo-MCP is essentially a translation layer. The Model Context Protocol (MCP) is an open standard that lets AI models use external tools and resources securely. DevTo-MCP takes the complex world of Forem API endpoints and turns them into simple, standardized functions that AI assistants (like Claude Desktop, Cursor, and custom Gemini agents) can seamlessly trigger.

During the development process, Google Gemini played several pivotal roles:

1. Architectural Guidance and Type Safety

Building an MCP server requires strict data validation. AI models can sometimes hallucinate parameters, so your server's defense must be ironclad. I decided to build DevTo-MCP using TypeScript, Node.js, and Zod for runtime validation.

Gemini helped me quickly map out the Forem API responses to Zod schemas. For example, when defining the create_article tool, Gemini assisted in generating the complete schema configuration:

server.tool(
    "create_article",
    "Create a new article on DEV Community.",
    {
        title: z.string().describe("Title of the article"),
        body_markdown: z.string().optional().describe("Article content in markdown"),
        published: z.boolean().optional().describe("Whether to publish immediately"),
        tags: z.array(z.string()).max(4).optional().describe("List of tags (max 4)"),
        canonical_url: z.string().url().optional(),
        organization_id: z.number().int().optional()
    },
    async (params) => {
        // Implementation logic
    }
);

Thanks to Gemini's suggestions, added strict .max(4) constraints and .url() validations to ensure we never send malformed data to the Forem API.

2. The Self-Healing API Client

Forem's API deals with millions of requests, meaning rate limits and occasional network blips are part of the game. I wanted my MCP server to be resilient. I tasked Gemini with helping me write a self-healing HTTP client.

Gemini generated the core logic for a robust fetch wrapper that:

Reads x-ratelimit-remaining headers.
Implements an exponential backoff strategy for 429 (Too Many Requests) and 500 errors.
Provides type-safe generic responses.

// A simplified look at the retry logic we implemented
private async request<T>(...): Promise<T> {
    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
        try {
            const response = await fetch(url, options);
            if (response.ok) return await response.json();
            
            if (this.isRetryable(response.status)) {
                const delay = this.getRetryDelay(attempt);
                await this.sleep(delay);
                continue;
            }
        } catch (error) {
             // Handle network level errors
        }
    }
}

3. CI/CD and NPM "Trusted Publishing"

A crucial goal was to automate the publishing of this package to NPM using GitHub Actions. I wanted to use modern OpenID Connect (OIDC) (NPM's Trusted Publishing) to avoid hardcoding NPM_TOKEN secrets.

I was stuck with persistent 404 errors during the pipeline execution. I pasted my YAML into Gemini, and it instantly spotted the missing piece: my workflow was missing the environment: production declaration required to establish trust.

jobs:
  publish:
    runs-on: ubuntu-latest
    environment: production  # <-- The magic line Gemini pointed out!
    permissions:
      id-token: write

Demo

The project is fully open-source and available here:
GitHub: furkankoykiran/DevTo-MCP

You can install and use it in any MCP-compatible client (like Claude Desktop) by simply adding it to your configuration:

{
  "mcpServers": {
    "devto": {
      "command": "npx",
      "args": ["-y", "devto-mcp"],
      "env": {
        "DEVTO_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Once installed, your AI assistant can fetch your latest followers, create article drafts, and analyze your reading list tags dynamically!

What I Learned

Building this project taught me several invaluable lessons:

The Art of "Feature Cutting"

Initially, I wanted to include a tool that allowed users to add reactions (like, unicorn, fire) to articles via the AI. However, I consistently encountered unreliable 401 errors from the API side. As tempting as it was to keep debugging it, I learned that in building AI tools, reliability is paramount. If an AI thinks it successfully reacted to a post but didn't, it breaks the chain of trust. I had to learn the difficult engineering skill of "Feature Cutting" and disabled the tool for the MVP.

Fallback Mechanisms for UX

When the AI tried to fetch a "Draft" article using the standard get_article_by_id endpoint, Forem would return a 404. Initially, the AI would give up and respond, "This article doesn't exist."
I learned to build fallback loops. Now, if the server receives a 404, it automatically makes a secondary request to /articles/me/all, searches for the ID locally, and returns the draft. This completely changed how smoothly the AI interacted with unpublished content.

Modern Release Pipelines

I leveled up my Devops skills by successfully setting up an automated, secret-less NPM release pipeline using OIDC and GitHub Actions, understanding exactly when and why workflows trigger.

Google Gemini Feedback

My experience with Google Gemini was incredibly positive, with a few notable learning curves.

What Worked Well:

Boilerplate and Structure: Gemini was fantastic at instantly generating the foundational boilerplate for a TypeScript Node project.
Error Decoding: When I encountered cryptic TypeScript errors regarding complex generic types for my API wrapper, Gemini was able to decipher them and explain the exact configuration changes needed in my tsconfig.json.
Regex and Parsing: Writing the logic to safely sanitize markdown payloads before sending them to the API was made trivial thanks to Gemini's rapid regex suggestions.

Where I Encountered Friction (The Candid Truth):

API Hallucinations: Because the Forem API has changed over time, Gemini occasionally hallucinated endpoints or parameter names that didn't exist or were deprecated. For example, it suggested sending data in a structure that the current API rejected. This actually reinforced my decision to use Zod—building strict validation layers meant I caught these AI hallucinations in my test environment immediately.
Context Window Management: When working across multiple files (api-client.ts, server.ts, and the Zod schema files), I sometimes found Gemini losing the thread of the specific generic types we had agreed upon earlier in the conversation. Reminding it of the interface definitions occasionally disrupted the flow state.

Look Forward

The future of software engineering lies in AI assistants that have secure, predictable access to our development ecosystems. DevTo-MCP is my contribution to ensuring the DEV community isn't left behind in this AI revolution.

I plan to expand DevTo-MCP to include organization-level analytics, more robust comment threading capabilities, and eventually figuring out a secure way to re-enable that elusive "Reactions" tool!

Thank you to MLH and Google for hosting this challenge, it was the perfect catalyst to reflect on this build journey.

(P.S. As a special proof-of-concept, this very article was drafted, formatted, and published autonomously to DEV.to by my AI Assistant (Gemini) using the DevTo-MCP server I built! A little meta-magic to wrap things up! )

Ethni-CITY: The New Travel App

Wed, 18 Mar 2026 15:04:08 +0000

If you're chronically online like I am, you're used to seeing tons of reels of people who travel to all these "authentic" destinations: Sao paulo, Marrakech, Cairo, Bangkok, and Bali. On Instagram or TikTok, it's pretty common to accompany your posts with a soundtrack, and it's the norm to post the latest trending songs to garner likes and reposts.
No shame here.
We all want validation, but so do the local economies we're coming from, and they hardly benefit when our money goes to international hotel chains and global brands. However, there are a few ways we can support locals while still making sure your pics eat, and one of them is by supporting local artists.
With Ethni-CITY, we connect your pics to the local artists of the countries you visit to curate a niche storyboard that puts artists' songs on your posts, helping them monetize their craft, gain recognition, and in turn boost their micro-economy as your pics garner likes.

To build this, I weaved spatial data with cultural analysis.

Using Gemini 3.1 pro preview as the main model, the app performs a deep multimodal analysis of your uploaded photos and then identifies the city and country the picture was taken in by looking for landmarks, cultural motifs, textile patterns and lighting conditions to determine.
I used Cesium JS along with Google Cloud photorealistic tiles, the agent transports you to the location of the photo, helping to tell a centric story.
To ensure the app survives the "Hackathon Hug," I implemented a hierarchical fallback logic:
- Tier 1: gemini-3.1-pro-preview for high-fidelity creative direction.
- Tier 2: gemini-2.0-flash for high-speed fallback.
- Tier 3: gemini-1.5-flash-8b for emergency quota resilience.

CHALLENGES FIXED:

By integrating a heavyweight library like Cesium into NextJS App router environment, posed significant challenges with asset serving and Typescript definitions. I had to automate the movement of Cesium's build assets into the public directory during the pre-build phase to ensure the tiles are rendered correctly in production.

I'm grateful for Gemini for providing the tools to curate this experience and help promote local artists from around the world.

Explore the project on GitHub:[ https://github.com/david-ac1/Ethni-CITY]
Watch the demo:[ https://youtu.be/kdrUzPtRw9Y?si=EzWt6DvbdbLjOk4V]

#GeminiLiveAgentChallenge #GoogleAI #GoogleCloud #Gemini

Autopilot - A Technical Post-Mortem: I Fired Myself to Build an AI Army with Gemini

Wed, 11 Mar 2026 06:58:28 +0000

1. The Genesis: The Builder's Paradox

In the world of engineering and technical blogging, we often face the "Builder's Paradox": we can spend 40 hours perfecting a complex architecture, defining an S&OP data pipeline, or debugging microservices, but we cannot seem to find 15 minutes to effectively package and promote that work on social media.

I reached that breaking point with Datalaria. The content was there, the technical depth was solid, but distribution suffered due to a massive bottleneck: myself. I hated the marketing overhead.

So, I made a strategic decision: I fired myself from the Community Manager role. In my place, I built Project Autopilot: an autonomous, event-driven orchestrator running entirely inside GitHub Actions. Every time I push a new Markdown file (Hugo) to the repository, the system wakes up, extracts context using Google Gemini, and employs CrewAI to generate structured Twitter threads and LinkedIn posts.

The initial conceptual diagram was simple: Text goes in, AI does magic, posts come out. The reality of building a deterministic pipeline with stochastic LLMs proved to be a much deeper engineering challenge.

2. Under the Hood: The Gemini Engine

To build a CI/CD pipeline that writes content based on deeply technical articles (spanning Data Science, Operations, and S&OP processes), a simple string-parsing Python script wasn't going to cut it. We needed heavy reasoning and enormous memory capacity.

This is where Google's Gemini models became the critical engine of the architecture.

Massive Context Ingestion with Gemini Pro

Technical posts, especially those detailing Sales & Operations Planning (S&OP) or data hygiene with Python, are long and dense. They contain business logic, code snippets, and diagrams. I chose Gemini Pro for the initial Analyst Agent because of its massive context window and high retention. It can ingest a 3,000-word tutorial without "forgetting" the core premise established in the first paragraph.

Structured Data Extraction with Gemini Flash

While Gemini Pro handled the heavy comprehension, I needed an incredibly fast model for repetitive formatting and metadata extraction. Gemini Flash became the go-to for these rapid-fire tasks.

However, CI/CD pipelines require strict determinism. An LLM chatting in natural language breaks automation. I had to force Gemini to act as a strict data processor connecting the LLM output directly to the next GitHub Action step. Here is a real fragment of how we enforced strict JSON outputs using the Gemini API:

import google.generativeai as genai
import os
import json

genai.configure(api_key=os.environ["GEMINI_API_KEY"])

def extract_metadata(markdown_content):
    # We rely on Gemini Flash for speed and strict JSON formatting
    model = genai.GenerativeModel(
        model_name="gemini-1.5-flash",
        generation_config={
            "temperature": 0.1,
            "response_mime_type": "application/json",
        }
    )
    
    prompt = f"""
    Analyze the following technical Markdown post.
    Return ONLY a valid JSON object matching this schema:
    {{
        "summary": "string",
        "key_takeaways": ["string", "string"],
        "target_audience": "string",
        "suggested_hashtags": ["string"]
    }}
    
    CONTENT:
    {markdown_content}
    """
    
    response = model.generate_content(prompt)
    return json.loads(response.text)

By setting response_mime_type="application/json", we eliminated the parsing errors that plague so many agentic workflows, allowing the orchestrator to elegantly pass metadata to the specialized CrewAI Copywriter Agents.

3. The Friction: The Good, The Bad, and The Ugly

Integrating generative AI into a rigid CI/CD workflow is rarely as seamless as the quick-start documentation claims. Here is the raw reality of building with agents in production.

The Good: Speed as a Feature

In a CI/CD environment, latency translates directly to runner costs. The inference speed of Gemini 1.5 Flash is staggering. By routing simple formatting tasks and metadata extraction to Flash, and reserving Gemini 1.5 Pro strictly for deep reasoning within CrewAI's Analyst role, we optimized both speed and cost. LangChain provided the glue, but Gemini provided the horsepower. Out-of-the-box, its ability to natively parse complex Markdown structures (including embedded Mermaid diagrams and code blocks) saved me days of writing fragile regex parsers.

The Bad: Stochastic Models vs. Deterministic Pipelines

The core engineering friction came from an impedance mismatch. GitHub Actions expects deterministic, step-by-step execution. LLMs are inherently stochastic.

Even with temperature set to 0.1, a CrewAI agent might occasionally hallucinate a non-existent standard Markdown tag or subtly break a requested paragraph structure for LinkedIn. I quickly learned that Prompt Engineering is not enough; you need Defensive Programming. I had to wrap execution chains in strict Try/Catch blocks and implement Pydantic schemas to validate every single output segment. The LLM could not be trusted blindly to hit a social media API. It had to be heavily constrained, validated, and sanitized before any POST request was executed. We essentially had to build a deterministic "quality gate" around a non-deterministic brain.

The Ugly: Infinite Delegation Loops and Runner Timeouts

The ugliest moments happened inside the GitHub Actions runners. CrewAI features an autonomous delegation mechanism where agents can pass tasks to one another. In theory, this is brilliant. In practice, without strict guardrails, it's a disaster.

Occasionally, the Analyst Agent and the Writer Agent would get stuck in an infinite, highly-polite "thinking loop," debating the best approach to summarize a technical paragraph.

Because GitHub Actions charges by the minute, these silent loops would devour runner time until the system forcefully halted the pipeline with a frustrating Error 143 (SIGTERM). Fixing this required deep intervention: disabling unnecessary delegation in CrewAI, enforcing hard timeouts (max_execution_time) at the agent level, and building strict fail-safes so the pipeline would cleanly abort rather than hang indefinitely.

4. The Takeaway: Operations Engineering

This project fundamentally shifted my mindset. Integrating AI into workflows is not a Prompt Engineering problem; it is a Systems Engineering and CI/CD problem.

Through this extreme "dogfooding" experiment, I learned to treat content and data pipelines with the exact same rigor I apply to a physical Supply Chain. An AI Agent is basically a highly capable but occasionally unpredictable node in an operations network. You must build fault tolerance, clear contracts (JSON schemas), and quality gating around it.

5. Looking Forward: The S&OP Pivot

Project Autopilot solved my distribution problem. But automating social media was merely the sandbox.

Now that Gemini and CrewAI have proven they can reliably ingest complex unstructured text, extract meaning, and orchestrate actions, the next step on the Datalaria roadmap is much more ambitious. I am taking this exact multi-agent architecture and pivoting it toward enterprise operations.

Instead of reading Markdown to write tweets, the next iteration of these Gemini-powered agents will ingest fragmented ERP data, emails, and Excel dumps to automate data hygiene and summarize risks for S&OP (Sales & Operations Planning) meetings. We are moving from solving the Builder's Paradox to optimizing real-world supply chains.

The AI army is built. Now it's time to put it to real work.

Autopilot - The Creatives: How I Programmed an AI to be Cynical on Twitter and Corporate on LinkedIn

Wed, 11 Feb 2026 07:10:42 +0000

In Post 2: The Brain, we achieved something technically important: a Python script capable of reading my technical articles and extracting their essence into a structured JSON.

But I have a problem. If I publish a JSON on Twitter, no one is going to read it.

Data is cold. Social media is emotional. For this "Autopilot" system to work, I don't need more analysts; I need creatives. I need writers who understand the psychology of each platform.

Today, we are going to give the machine a soul. We are going to create "The Creatives."

The Role Theory ( The Stanislavski Method for AI)

Large Language Models (LLMs) like Gemini are, in essence, method actors. If you ask them to "write a tweet," they will give you a generic, boring tweet full of hashtags like #Technology #Innovation.

But if you give them a role, a backstory, and a motivation, their behavior changes radically. In prompt engineering, this is the difference between a chatbot and an agent.

For Datalaria, I don't want a generic voice. I want to cover two ends of the spectrum:

The Chaos (Twitter/X): Brief, direct, slightly cynical, and allergic to corporate speak.
The Order (LinkedIn): Professional, inspiring, focused on business value.

Designing the Personalities (The Code)

Using CrewAI, defining these personalities is as simple (and complex) as writing a biography. Here is the actual code from src/agents.py that defines my two new digital employees.

1. The Tech Influencer (Twitter)

I explicitly asked it to hate corporate jargon and use lowercase for aesthetics.

def twitter_writer_agent(self):
    return Agent(
        role="Tech Twitter Influencer",
        goal="Convert structured insights into a viral Twitter thread",
        backstory="""You are a tech influencer who hates corporate jargon. 
        You write in a punchy, provocative style. 
        You use lowercase often for aesthetic. 
        You focus on the 'Marketing Hooks' from the input. 
        You NEVER use hashtags like #Technology, only niche ones.""",
        llm=self.llm
    )

2. The Thought Leader (LinkedIn)

Here we look for the "Broetry" style (short sentences with lots of whitespace) that works on LinkedIn.

def linkedin_writer_agent(self):
    return Agent(
        role="LinkedIn Thought Leader",
        goal="Write a high-engagement LinkedIn post",
        backstory="""You are a respected Voice in the Tech industry. 
        You write with empathy and professionalism. 
        You use the 'Broetry' style (short paragraphs, lots of whitespace). 
        You focus on the 'Key Takeaways' and business value. 
        You start with a strong hook.""",
        llm=self.llm
    )

Refactoring: The Multilingual Challenge

Datalaria is a global blog, so I faced a challenge: Do I need to create 4 different agents to write in Spanish and English?

The engineering answer is NO. An agent is an entity with a personality; language is just a tool.

Instead of duplicating agents, I duplicated the Tasks (Tasks). In src/tasks.py, I now explicitly define the output language:

def twitter_task_es(self, agent, context):
    return Task(
        description="Escribe un hilo viral en ESPAÑOL basado en el análisis...",
        agent=agent,
        expected_output="Un hilo de Twitter en Español..."
    )

def twitter_task_en(self, agent, context):
    return Task(
        description="Write a viral Twitter thread in ENGLISH based on the analysis...",
        agent=agent,
        expected_output="A Twitter thread in English..."
    )

This makes my pipeline scalable. If tomorrow I want to publish in French, I just add a task, I don't hire a new agent.

The Battle of the Agents: Real Results

To test this, I used my article on "S&OP Processes with AI and BPMN." It's a dense and boring topic if not sold well.

Let's see what the agents did with the same input.

The Result on Twitter (The Cynic)

Author's note: This result hurt a little; it's more direct than I am.

stop drowning in walls of text.
manually turning industrial narratives into diagrams is a grind. it’s a waste of brainpower.
we’re using genai to turn messy s&op docs into precise bpmn diagrams in seconds.

here is how you stop being a human translator.

most "business analysis" is just expensive friction.
genai identifies hidden dependencies and feedback loops that human bas miss.
it’s not just drawing; it’s uncovering the logic buried under corporate fluff.

ProcessEngineering #Industry40

The Result on LinkedIn (The Corporate)

Stop drowning in 'walls of text' and PDF graveyards.

Industrial processes are the heartbeat of your company.

But they are often buried in dense S&OP narratives that no one reads.

This creates a massive gap between what the business needs and what engineering builds.

I’ve spent years seeing Technical Leads and Ops Managers struggle with this "translation layer."

The good news? Generative AI is changing the game.

By using AI as a virtual Business Analyst, you can transform complex industrial narratives into precise BPMN diagrams in seconds.

It’s not just about speed. It’s about clarity.

How is your team currently bridging the gap between business narratives and technical execution? Let’s discuss in the comments.

Conclusion

The difference is abysmal. The same model (Gemini 1.5 Flash), reading the same article, has generated two pieces of content completely distinct, adapted to the channel and the language.

I already have:

The Brain that understands the code.
The Creatives that write the copy.
The files generated on my hard drive.

But there is still a "human" in the loop. I still have to run python main.py manually and copy-paste these texts onto social media.

In the next post, we enter hostile territory. We are going to try to connect these agents with the outside world.

Coming soon Post 4: The API Nightmare. I will try to connect my agents to Twitter and LinkedIn and (probably) almost lose my mind in the process.

Source Code: The updated code with the new agents and multilingual support is available in the /autopilot folder of the GitHub repo.

Autopilot - The Brain: Configuring Gemini and CrewAI to Read My Blog

Sun, 08 Feb 2026 09:02:37 +0000

In Post 1: The Strategy, I promised I wouldn't use third-party tools to manage my social media. I promised to build an "army of agents."

Today, we leave PowerPoint behind and open the IDE. We are going to build the system's Brain.

Today's goal is technical and concrete: create a Python script capable of reading a .md file from my local repository, "reading" it as a senior engineer would, and returning a structured analysis in JSON.

The Tech Stack: Speed Over Brute Force

For this task, I made two architectural decisions:

The Orchestrator: CrewAI. I need something that handles "Agents" and "Tasks," not just text strings. CrewAI allows me to define roles (who you are) and goals (what you want), which is vital for the next steps.
The Model: Google Gemini Flash. At first, I tried using the most powerful model (Pro), but I realized a beginner's mistake: for massive reading and data extraction tasks, you don't need the philosopher, you need the fast librarian. Flash is much faster, cheaper (free in the current tier), and has a gigantic context window.

Step 1: Repository Hygiene (Clean Monorepo)

Before writing code, we must organize the house. My blog is built on Hugo, and I don't want to clutter the website folder with Python scripts.

I opted for a "Clean Monorepo" structure. I created an autopilot folder at the root of the project that acts as an independent module.

datalaria/
├── content/           <-- My Markdown posts (Hugo)
├── themes/
├── autopilot/         <-- THE NEW BRAIN 
│   ├── .env           <-- WATCH OUT! Keys go here (Ignored by Git)
│   ├── main.py        <-- Entry point
│   └── src/           <-- Agent and Task Logic
└── .gitignore         <-- Configured to protect my secrets

Lesson learned: Configure your .gitignore before making the first commit. If you upload your API Key to GitHub by mistake, bots will take seconds to find it, or worse, you might encounter unwanted costs from other users finding your API Key.

Step 2: The Code (Hands-on)

The heart of this system isn't main.py, but how we define the agent. Using the crewai and langchain_google_genai libraries, I defined my first digital employee: "The Analyst."

The "Obsession with OpenAI" Problem

Here I hit the first wall. CrewAI is designed by default to look for an OpenAI API Key (GPT-4). Although I configured Gemini, the script failed with the error:

ValueError: OPENAI_API_KEY is required

The solution was to explicitly force the LLM (Large Language Model) inside the agent definition. This is what the code looks like in src/agents.py:

from crewai import Agent
from langchain_google_genai import ChatGoogleGenerativeAI
import os

class BlogAgents:
    def __init__(self):
        # We configure Gemini Flash explicitly
        self.llm = ChatGoogleGenerativeAI(
            model="gemini-1.5-flash",
            verbose=True,
            temperature=0.2, # Low temperature = More analytical, less creative
            google_api_key=os.getenv("GOOGLE_API_KEY")
        )

    def analyst_agent(self):
        return Agent(
            role='Senior Tech Editor & Data Analyst',
            goal='Analyze raw content to extract structured insights',
            backstory='You are a veteran tech editor...',
            allow_delegation=False,
            llm=self.llm  # <--- THIS LINE IS CRITICAL. If you remove it, it will look for OpenAI.
        )

Step 3: Prompt Engineering (JSON Mode)

For this to be useful, the agent can't simply "chat" about the article. I need data that I can process computationally later.

In src/tasks.py, I defined the task with strict output instructions. I didn't use the API's native "JSON Mode" (which is sometimes complex to configure), but instead relied on the model's instruction-following capability:

"OUTPUT FORMAT: Return ONLY a valid JSON object with keys: summary, target_audience, tech_stack, key_takeaways, marketing_hooks."

The Result: It Works!

I ran the script against one of my densest technical articles (about S&OP processes). I was afraid the model might hallucinate or get lost in the text.

The result in the terminal was this clean JSON:

{
  "summary": "This post demonstrates how Generative AI bridges the gap between complex business narratives and technical execution...",
  "target_audience": "Business Analysts, Industrial Engineers, Operations Managers...",
  "tech_stack": [
    "Generative AI (LLMs)",
    "BPMN 2.0",
    "Mermaid.js",
    "Gemini API"
  ],
  "marketing_hooks": [
    "Stop drowning in dense business requirements!  Learn how to use AI to turn messy narratives into professional BPMN diagrams...",
    "Documentation as Code is here.  See how LLMs can generate Mermaid.js diagrams..."
  ]
}

It's impressive. The model not only summarized the text but understood the deep context: it identified that the article talked about "Mermaid.js" and "BPMN" and generated marketing hooks ("marketing_hooks") that actually sound like something I would write on Twitter.

What's Next?

We already have the Brain (autopilot) capable of reading and understanding what I write in content. The data is structured and ready.

But a JSON doesn't get likes.

In the next post, we are going to build The Creatives. We will use this data to feed two new agents with opposing personalities: a viral expert for Twitter and a corporate strategist for LinkedIn. And we will see how Prompt Engineering can drastically change the tone of an AI.

Source Code: You can see the code for this module in the /autopilot folder of the Datalaria GitHub repository.

Gemini Cost Management: Building Powerful AI Without Losing Control of Costs

Wed, 04 Feb 2026 07:40:51 +0000

AI adoption is accelerating fast—but so are AI bills.

As teams integrate large language models into products, workflows, and platforms, a new challenge has emerged:
How do you manage AI costs without limiting innovation?

This is where Gemini Cost Management becomes critical—ensuring that AI usage is efficient, predictable, and scalable, not a financial surprise.

What Is Gemini Cost Management?

Gemini Cost Management refers to the strategies, controls, and architectural patterns used to monitor, optimize, and govern usage of Gemini models, including:

Token consumption
Model selection (Flash vs higher-capability models)
Request frequency
Multimodal usage (text, image, video)
Real-time vs batch workloads

It’s not just about saving money—it’s about using AI responsibly and sustainably.

Why AI Costs Grow So Fast

AI costs are different from traditional cloud costs.

They grow because of:

Large prompts
High-frequency requests
Long conversations
Multimodal inputs (images, documents)
Unbounded agent loops
Overuse of powerful models where smaller ones would work

Without guardrails, even a small feature can quietly become expensive.

The Role of Gemini Models in Cost Strategy

Google Gemini offers multiple model tiers, each designed for different cost–performance needs.

Gemini Flash Models

Best for:

Real-time APIs
High-volume requests
Chatbots
Classification and extraction
Streaming responses

Lowest latency + lower cost per request

Higher-Capability Gemini Models

Best for:

Deep reasoning
Complex planning
Long-context analysis
Advanced multimodal understanding

Higher cost, higher intelligence

Cost management starts with choosing the right model for the job.

Key Pillars of Gemini Cost Management

1. Model Right-Sizing

Not every task needs the most powerful model.

Examples:

Use Gemini Flash for summarization, tagging, routing
Escalate to advanced models only when confidence is low
Mix models in a single workflow

This alone can reduce costs dramatically.

2. Prompt Efficiency

Poor prompts waste tokens.

Cost-aware prompt design includes:

Short system instructions
Avoiding repeated context
Using references instead of raw text
Structuring inputs clearly

Smaller prompts = lower cost + faster responses.

3. Token & Usage Monitoring

You can’t control what you don’t measure.

Track:

Tokens per request
Tokens per user
Tokens per feature
Peak usage windows
Outlier requests

Usage visibility turns cost from a surprise into a decision.

4. Caching & Reuse

Many AI responses don’t need to be regenerated.

Cache:

Common prompts
Repeated queries
Static summaries
Frequently accessed insights

This avoids unnecessary calls and stabilizes spend.

5. Rate Limiting & Quotas

Protect yourself from:

Abuse
Infinite loops
Unexpected spikes
Misconfigured agents

Cost-safe systems enforce:

Per-user limits
Per-feature quotas
Daily or monthly caps

Cost Management for Gemini Agents

Agent-based systems can be powerful—and dangerous for costs.

Best practices:

Hard stop conditions
Max steps per agent run
Cost budgets per task
Confidence thresholds before escalation
Human-in-the-loop checkpoints

Agents should be goal-driven, not open-ended.

Multimodal Cost Considerations

Gemini supports text, images, documents, and more.

Cost-aware multimodal usage:

Resize images before sending
Extract text locally when possible
Send references instead of raw files
Avoid repeated multimodal inputs in loops

Multimodal intelligence is powerful—but should be intentional.

Business Benefits of Strong Gemini Cost Management

Predictable Spend

No surprise bills at the end of the month.

Scalable AI Adoption

Teams can ship AI features with confidence.

⚡ Better Performance

Optimized prompts and models reduce latency.

Smarter Architecture

Cost awareness leads to better system design.

Governance & Compliance

Clear usage boundaries across teams and products.

Common Mistakes to Avoid

Using one model for everything
Ignoring token usage metrics
Letting agents run without limits
Re-sending full context every time
Treating AI costs like static cloud costs

AI spend is dynamic—your controls must be too.

The Future of AI Cost Management

AI platforms are moving toward:

Budget-aware agents
Cost-optimized routing
Adaptive model selection
Built-in usage intelligence
Real-time spend feedback

Cost management won’t slow AI innovation—it will enable it.

Final Thoughts

Gemini makes it easy to build intelligent, multimodal systems—but smart teams build them with cost in mind from day one.

Gemini Cost Management is about balance:

Power without waste
Speed without excess
Innovation without financial risk

When AI becomes a core part of your product, cost awareness becomes a core engineering skill.

https://www.linkedin.com/posts/edong186_if-scaling-ai-is-about-engineering-managing-activity-7424085443115327488-FvRK

Let’s stay connected:

Instagram: https://www.instagram.com/angular_development/

Facebook: https://m.facebook.com/learnangular2plus/

Threads: https://www.threads.net/@angular_development

Medium: https://medium.com/@eraoftech

coderlegion: https://coderlegion.com/user/Sunny

Quora: https://neweraofcoding.quora.com/

YouTube: https://www.youtube.com/@neweraofcoding

LinkedIn: https://www.linkedin.com/company/infowebtech/

Hashnode: https://neweraofcoding.hashnode.dev/

GitHub: https://github.com/angulardevelopment/ | sunny7899

BlueSky: https://bsky.app/profile/neweraofcoding.bsky.social

Substack Newsletter: https://codeforweb.substack.com/

Pinterest: https://in.pinterest.com/tech_nerd_life/

dev.to: https://dev.to/sunny7899

Looking for web dev trainings: https://beginner-to-pro-training.vercel.app/

Software development services: https://infowebtechnologies.vercel.app/

Contribution to the web development community: https://code-for-next-generation.vercel.app/

Book a session: https://topmate.io/softwaredev

Telegram Channel: https://t.me/neweraofcoding

Slack Community: Invite

Discord Community: http://discord.gg/Nuc9YRngHz

Buy me a coffee on Ko-fi: https://ko-fi.com/softwaredev

Ebooks: https://apexsunshine.gumroad.com

For business inquiries: [*Emails are not allowed*](mailto:Emails are not allowed)

Thank you for being a part of the community. Happy coding!

Customised Universal Converter App

Sat, 31 Jan 2026 08:52:02 +0000

Universal Converter Pro

Tired of relying on generic online converters or dusting off old formulas?

I built Universal Converter Pro a fast and clean web application designed to be a digital "Swiss Army Knife" for engineering and technical needs. Created with the help of AI, it solves the daily challenge of complex unit conversions. Some features:

6 Core Categories: Comprehensive tools for Dimension, Energy, Time, Mechanics, Computing, and Radio Frequency.
Specialized Units: Handles engineering tasks like converting Frequency to Wavelength ($\lambda = c / f$) or Pascals to PSI.
Utility Tools: Includes a specific number format converter (swapping dots and commas for thousands/decimals).
Educational Context: Not just a calculator; it explains the science behind the units (e.g., Binary vs. Decimal bytes).
AI-Powered Development: Architecture and code generated using Gemini Canvas.
Scalable Design: A living project designed to expand with new professional needs.

Built with HTML5, CSS3, and Vanilla JavaScript with Gemini AI assistance. Lightweight, responsive, and 100% serverless.

If you want to know the details about how I built this "Digital Swiss Army Knife" with AI, please read the following article: Building My Digital 'Swiss Army Knife': A Custom Unit Converter with AI

Building My Digital 'Swiss Army Knife': A Custom Unit Converter with AI

Thu, 29 Jan 2026 06:49:42 +0000

In any technical or engineering discipline, our daily work is filled with small but constant unit conversion tasks. We switch from Pascals to PSI, Kilowatts to Horsepower, Gigabytes to Terabytes, or from frequency to wavelength. In my university days, we had so-called cheatsheets, which we used to keep handy on our calculators, folders, or notebooks for daily use (not for exams, of course ). Now, in the professional world, with the proliferation of all kinds of apps and websites, it's no longer necessary to rely on these resources, as we have a multitude of options available that allow us to quickly look up any conversion or unit, no matter how obscure.

However, given the overwhelming number of options and this being such a recurrent and necessary task, I set myself a challenge: could I create my own unit converter? One that was fast, clean, visually appealing, and, above all, a living project—a kind of "digital Swiss army knife" that I could expand over time according to my personal and professional needs. The answer, as in other blog projects, I found in AI. This post describes my own unit converter, covering its development from scratch with the support of Gemini's Canvas feature to create a web application with multiple pages and categories.

The Process: From Idea to Conception

The goal was to create a modern, intuitive web application with clear navigation by categories, and that was smooth and easy to use. Instead of starting to write code from scratch, I began a conversation with Gemini, describing my vision:

"Create the structure for a multi-page HTML web application. The application will be a format and unit converter. The main page should display cards for the categories: Dimension, Energy, Time, Mechanics, Computing, and Radio Frequency with basic conversions. Each card should link to a dedicated conversion page for the corresponding category from a homepage where, in addition to the navigation cards for each category, there should be a format converter for the '.' and ',' symbols for thousands and decimals in numbers."

Gemini's Canvas feature allowed me to see in real-time how the AI generated not just the code, but the complete project structure. After the initial draft and a couple of additional iterations focused on refining the design and fine-tuning the units, a first operational version of the application came to life: My unit conversion application

A Look at the Categories and Their Units

What makes a tool like this useful is understanding what we are converting. That's why the "Universal Converter Pro" not only calculates but also aims to be educational. These are the initial categories and the science behind their units:

1. Dimension: Measuring the Space Around Us

This category groups the fundamental measures of physical space.

Length:
- What is it? It is the measure of one dimension, the distance between two points.
- How is it calculated? All conversions are calculated using the meter (m) as the reference unit. The formula converts the initial value to meters and then to the final unit.
Area:
- What is it? It is the measure of a two-dimensional surface.
- How is it calculated? Similarly, the calculation is standardized using the square meter (m²) as the base unit.
Volume:
- What is it? It is the measure of the space an object occupies in three dimensions.
- How is it calculated? The base unit for volume in the application is the liter (l), making it easy to convert between metric units and others like gallons or cups.

2. Energy: The Capacity to Do Work

Here we group the units that describe how energy is transferred and used.

Energy:
- What is it? It is the capacity of a system to perform work.
- How is it calculated? The Joule (J) is the base unit of the International System. From it, conversions to calories, watt-hours, etc., are performed.
Power:
- What is it? It is the rate at which energy is transferred or work is done. It's not the same to have energy as to be able to use it quickly.
- How is it calculated? The base unit is the Watt (W), which is equivalent to one Joule per second.
Temperature:
- What is it? It is a measure of the thermal energy or heat of a body.
- How is it calculated? Unlike others, temperature does not use a simple conversion factor. The application uses specific formulas, always converting the input to degrees Celsius (°C) as an intermediate step to then calculate the output unit (Fahrenheit or Kelvin).

3. Computing: The World of Bits and Bytes

The units that define our digital world.

Data Storage:
- What is it? It measures the capacity to store digital information.
- How is it calculated? The fundamental unit is the Byte (B). It is important to note that in computing, multiples are not decimal (x1000), but binary (x1024). Thus, 1 Kilobyte is 1024 Bytes.
Bandwidth:
- What is it? It measures the data transfer rate in a network.
- How is it calculated? Its base unit is bits per second (bps). In this case, the multiples are decimal (kbps, mbps, gbps), as they refer to transmission speed, not storage.

4. Time: Our Most Precious Dimension

Although it seems simple, time conversion is fundamental in many calculations.

Time:
- What is it? It is the magnitude that measures the duration or separation of events.
- How is it calculated? All units are converted to the base unit, the second (s), to then calculate the final value in minutes, hours, days, etc.

5. Mechanics: The Forces that Move the World

This category is key in engineering and physics.

Mass:
- What is it? It is the measure of the amount of matter in a body. It should not be confused with weight, which is the force exerted by gravity on that mass.
- How is it calculated? The base unit is the Kilogram (kg).
Force:
- What is it? It is any interaction that, unopposed, changes the motion of an object.
- How is it calculated? The Newton (N) is used as the base unit, defined as the force required to provide an acceleration of 1 m/s² to an object of 1 kg of mass.
Pressure:
- What is it? It is the force applied perpendicularly to a surface.
- How is it calculated? The base unit is the Pascal (Pa), which is equal to one Newton per square meter (N/m²).

6. Radio Frequency: The Invisible Spectrum

Fundamental for telecommunications.

Frequency:
- What is it? It is the number of repetitions of a periodic phenomenon per unit of time. In waves, it is the number of cycles per second.
- How is it calculated? Its base unit is the Hertz (Hz), which is equivalent to one cycle per second.
Frequency to Wavelength:
- What is it? This is a special conversion that relates the frequency of an electromagnetic wave to its wavelength (the distance between two crests of the wave).
- How is it calculated? It is not a direct conversion but uses a physical formula: lambda = c / f, where lambda is the wavelength, f is the frequency, and c is the constant of the speed of light (299,792,458 m/s). The application converts the frequency to Hz, calculates the wavelength in meters, and then converts it to the desired length unit.

Conclusion: More Than a Tool, a Living Project

The "Universal Converter Pro" is the perfect example of how, thanks to AI, ideas and resources of great utility for our personal or professional daily life can be materialized. The process, in this case guided by Gemini Canvas, was incredibly agile, and the result is an application that not only solves my daily needs but also serves as a learning platform.

My goal is to continue expanding it with new categories and units as the needs arise. This is the new era of personal software development: we no longer depend on generic tools but have the power to build our own custom solutions, with an AI copilot that translates our ideas into functional code.

Sources and Resources:

Gemini: Official Gemini page to try its Canvas functionality
App's web: My unit conversion application

AI-Powered Flashcards

Mon, 26 Jan 2026 06:43:25 +0000

Boost Your Learning with AI-Powered Flashcards

Struggling to memorize complex terms or master a new language? I built a Custom Flashcard App designed to transform tedious study sessions into an efficient, AI-assisted experience. Whether for bilingual schooling or professional exams, it’s built for speed and focus. Key features:

Three Input Modes: Manual entry, bulk upload (.csv/.txt), or 100% AI-generated content.

Gemini AI Integration: Just enter a concept, and the AI automatically generates definitions, translations, and phonetics in seconds.

Bilingual Optimization: Seamlessly switch between languages—perfect for science, history, or vocabulary drills.

Smart Review Loop: The app tracks your mistakes and uses a "re-run" logic to ensure you master every card before finishing.

Lightweight Gamification: Real-time scoring, progress tracking, and celebratory animations to keep motivation high.

Privacy-Focused & Portable: No heavy databases—use your own Google AI Studio key for a completely custom and private experience.

Clean UI: Minimalist design to eliminate distractions and maximize cognitive retention.

Built with Python, JavaScript, and the Gemini API, this project proves how AI can act as a personal tutor to solve real-world learning hurdles.

If you want to dive into the story behind this project and see the step-by-step creation process, check out the full article here: [https://datalaria.com/en/posts/app_flashcards/]

Why this works:
Consistency: It uses the same emoji-bullet-link structure as your Weather post.

The "Hook": It starts with the pain point (memorization) and offers the solution immediately.

Technical Tease: It mentions the Gemini API and the "re-run" logic, which appeals to other developers.

Call to Action: It directs traffic back to your detailed "How-to" post.

Unlock Gemini’s True Potential: The One Setting You Need to Change Right Now

Thu, 11 Dec 2025 03:09:49 +0000

If you have used Google’s Gemini and found it impressive but ultimately disconnected from your actual work, you aren't alone. Many users describe the initial experience as talking to a very smart stranger—it knows the capital of France and can write a haiku, but it knows absolutely nothing about you, your projects, or your schedule.

However, the difference between Gemini being a novelty and a productivity powerhouse often comes down to a single, often overlooked toggle in the settings: The Google Workspace Extension.

The Problem: The "Generic" AI Trap

Out of the box, most AI chatbots operate in a silo. If you want Gemini to summarize a meeting note you wrote last week, you usually have to find the document, copy the text, paste it into the chat, and then ask your question. This friction defeats the purpose of having an intelligent assistant; you end up doing the heavy lifting of data retrieval yourself.

The Fix: Connecting the Dots

The "tiny adjustment" that transforms the experience is granting Gemini access to your personal Google ecosystem. By enabling the Google Workspace extension, you allow the AI to securely "read" your Drive, Gmail, and Docs.

How to enable it:

Open Gemini (on the web or mobile app).
Go to Settings.
Select Extensions (or "Connected Apps").
Toggle on Google Workspace.

How It Changes Your Workflow

Once this connection is made, Gemini stops being a generic chatbot and starts acting like a personalized executive assistant. Here is what becomes possible:

Instant Document Retrieval: Instead of digging through folders, you can ask, "Summarize the marketing plan I wrote last month," or "What were the key takeaways from the Project Alpha doc?" Gemini finds the specific file and generates the answer instantly.
Email Intelligence: You can stop searching for keywords in your inbox. Commands like "Check my emails for the electric bill due date" or "Summarize the email thread with the design team" yield immediate, specific results.
Cross-App Functionality: If you use Google Keep for lists, you can ask specific questions like, "What is on my shopping list?" or "Retrieve my inventory list from Keep," without ever opening the app.

The Privacy Question

Naturally, giving an AI access to your private emails and documents raises security concerns. Google has stated that when you use the Workspace extension:

Your content is used only to answer your specific prompt.
Your personal data is not used to train the public Gemini model.
The data remains within your secure enterprise or personal environment.

Verdict

If you have felt frustrated that AI tools feel "disconnected" from your reality, the Google Workspace extension is the missing link. It unifies your digital life—Drive, Docs, Gmail, and Keep—under one conversational interface.

By making this one small adjustment, you stop shouting questions into a void and start interacting with an assistant that actually knows who you are and what you are working on.

Model Context Protocol (MCP): A New Way to Connect Angular Apps with AI Servers

Wed, 20 Aug 2025 09:57:04 +0000

The rise of AI-powered applications has changed how we think about frontend–backend communication. Traditionally, Angular apps connect to REST APIs or GraphQL endpoints. But when we bring AI models into the mix, things become trickier:

How does the frontend pass context (user data, preferences, documents) safely to an AI model?
How does the backend ensure the model has the right context without overloading it with unnecessary data?
How can we standardize communication between tools, data sources, and AI systems?

This is where the Model Context Protocol (MCP) comes in.

What is MCP?

Model Context Protocol (MCP) is an emerging open standard designed to connect AI models with tools, servers, and data sources in a structured, secure, and reliable way.

Instead of just “sending prompts” to an AI model, MCP defines a protocol where:

The frontend (Angular) can request capabilities from the server.
The server exposes structured resources (databases, APIs, files, business logic).
The model gets only the context it needs — nothing more, nothing less.

Think of it as GraphQL for AI context, but protocol-based.

Why MCP Matters for Angular Developers

Most Angular apps today consume APIs. With AI in the mix, apps need to do more:

Context-Aware Queries
- Example: An Angular app for a CRM could ask the model:
  
  “Summarize the last 5 interactions with this customer.”
- MCP ensures the model only gets those 5 interactions, not the entire CRM database.
Standardized Tooling
- Instead of writing custom APIs for each AI use case, MCP defines a common language between Angular frontend, your server, and the AI model.
Security and Data Governance
- MCP prevents the model from having unrestricted access to sensitive production data.
- Access is explicitly granted via the MCP server, keeping data security front and center.
Future-Proofing
- As AI capabilities evolve, MCP ensures your Angular app can plug into new tools and models without constantly rewriting integrations.

How It Works (Simplified Flow)

Here’s what a simple Angular + MCP setup might look like:

Angular Frontend
- User interacts with UI (e.g., clicks “Summarize Customer History”).
- Angular calls your backend (MCP server) instead of talking to the AI directly.
MCP Server
- MCP server receives request and checks what context is allowed.
- It fetches only the relevant data from your database or APIs.
- It passes that structured context to the AI model.
AI Model
- Model receives a curated, secure context.
- It generates a response (e.g., a customer summary).
Angular UI
- Presenter/Service layer in Angular displays the AI’s response in the component.

Example Use Case: Angular Helpdesk App

Imagine you’re building a Helpdesk dashboard in Angular:

Without MCP: You’d have to manually build API routes to feed AI with customer tickets, chat logs, and metadata. Risk of oversharing or leaking sensitive info.
With MCP:
- Your Angular app requests: “context: last 3 unresolved tickets for customer X.”
- The MCP server ensures only those 3 tickets are passed to the AI.
- The AI generates a reply draft for the agent.

This separation ensures cleaner architecture, better security, and less boilerplate.

Benefits of MCP for Angular + AI Systems

✅ Thin frontend → Angular focuses on UI, not AI plumbing.
✅ Safer data access → MCP acts as a guardrail for context.
✅ Reusable server logic → One MCP server can power multiple frontends (Angular, mobile, CLI).
✅ Future-ready → Works across different AI models and tools.

Final Thoughts

AI will increasingly be part of modern Angular apps — whether for analytics dashboards, chatbots, or customer support assistants.

By adopting the Model Context Protocol (MCP), you:

Keep your Angular frontend clean and UI-driven.
Centralize context and security in the backend.
Empower AI models with the right data, without oversharing.

In short: MCP is the missing bridge between Angular frontends, backend systems, and AI-powered intelligence.

MCP use case is more of architectural decision - like the business wants to use different language and code packages. In the similar architectural category as to why people may choose to use microservices vs. monoliths—they don’t have to use MCP unless there’s a use case for it.

Getting Started with Google MCP Servers

look at https://github.com/google/mcp. This contains both remote (Google Managed) and local (open-source) MCP Servers that you can setup. All of them can be configured in Gemini CLI or other AI clients. One of the local MCP Servers is https://github.com/google/mcp-security.

You should expect more of the Security suite being available as a remote MCP Servers as we go along. We recently announced Google Maps, BigQuery, GCE and GKE being available with more to come. Tools could be limited at the moment but this option solves a big problem when it comes to Security since it is tightly integrated with IAM and more.
The bigger question is what are the features that you absolutely need but are not yet available as tools in the available MCP Servers?
The MCP Servers being released are not just MCP Wrappers over existing APIs for these services. They are a set of action-oriented tools or in some cases can interpret schemas and more. This plays a key role in avoiding the context issues that plague agents and instead shifts a lot of the work to the MCP tooling layer.

At the current moment MCPs have very little use cases.

they are rarely used by itself
normally u use it with LLMs or RAG
MCPs are basically like travel adapter, they help to make an api more usable

We are talking about extreme "productivity gains". Instead of hiring a 1000 devs, only 10 is hired. Instead of hiring a team doing many roles, a single person with Agents and MCP servers will do.

special path
.ai\mcp\mcp.json

What “MCP serve” means (quick clarity)

MCP server runs locally and exposes your project (files, commands, context) to AI tools inside Visual Studio Code.

It does NOT replace ng serve
MCP = AI context bridge
ng serve = Angular dev server

They work together.

Architecture (simple mental model)

VS Code
 ├── Angular Project
 ├── ng serve (runs app)
 └── MCP Server (exposes project context to AI)

✅ Prerequisites

Make sure you have:

node -v
npm -v
ng version

If ng is missing:

npm install -g @angular/cli

1️⃣ Open Angular project in VS Code

code my-angular-app

Project structure should look like:

src/
 ├── app/
 │   ├── app.component.ts
 │   ├── app.routes.ts
 │   └── services/
 └── main.ts
angular.json

2️⃣ Install & setup MCP server

Inside your Angular project:

npm install -D @modelcontextprotocol/server-filesystem

Create a folder:

mkdir mcp

Create mcp/server.js

import { FileSystemServer } from "@modelcontextprotocol/server-filesystem";

const server = new FileSystemServer({
  rootDir: process.cwd(), // Angular project root
});

server.start();

Add script to package.json:

{
  "scripts": {
    "mcp:serve": "node mcp/server.js"
  }
}

3️⃣ Start MCP server

npm run mcp:serve

You now have an MCP server exposing:

Components
Services
Routes
Angular config
RxJS logic

4️⃣ Run Angular dev server (normal way)

In another terminal:

ng serve

Your app runs at:

http://localhost:4200

5️⃣ Connect MCP to VS Code

Install MCP-compatible extension (example):

Continue
Cursor
GitHub Copilot Chat (when MCP enabled)

Then configure MCP:

.vscode/settings.json

{
  "mcp.servers": {
    "angular-project": {
      "command": "npm",
      "args": ["run", "mcp:serve"]
    }
  }
}

Restart VS Code

6️⃣ What you can do now (Angular-specific )

Inside AI chat in VS Code, you can ask:

✅ “Explain data flow in this Angular app”
✅ “Refactor this service using signals”
✅ “Convert this component to standalone”
✅ “Find unused RxJS subscriptions”
✅ “Explain routing guards in this project”

MCP gives real project awareness, not guesses.

⚠️ Common mistakes

❌ Thinking MCP replaces ng serve
❌ Running MCP outside project root
❌ Not restarting VS Code
❌ Missing Node 18+

Best practice (Angular devs)

Run MCP + ng serve together
Use MCP for:
- Refactoring
- Architecture questions
- Debugging flows
Keep angular.json and tsconfig included in MCP root

What MCP is doing (1-liner)

MCP lets the AI read and reason about your real Angular codebase, not just generic Angular knowledge.

✅ Basic workflow (every time)

1️⃣ Start MCP server

npm run mcp:serve

Keep this terminal running.

2️⃣ Start Angular app (normal)

ng serve

MCP ≠ Angular server. Both run together.

3️⃣ Open AI Chat in Visual Studio Code

Use:

Continue / Cursor
Copilot Chat (MCP enabled)

Now the AI knows your project files.

Core MCP Usage (START HERE)

Ask about your project (read-only)

Best first prompts:

Explain this Angular project structure

How does data flow from components to services here?

What are the main routes in this app?

Find unused services or dead code

Ask about a specific file

Open a file, then ask:

Explain this component in simple terms

Is this service following Angular best practices?

Any RxJS issues or memory leaks here?

Refactor with confidence (SAFE)

Refactor this component to standalone

Convert this service to use signals

Improve performance of this component

Split this component into smart + dumb components

MCP ensures changes match your project, not examples.

Angular-specific power prompts

Signals

Can this component use Angular signals instead of RxJS?

Routing

Explain route guards used in this project

Cleanup

Find unused imports and modules

Testing

Generate unit tests for this service using current setup

⚠️ Common beginner mistakes

❌ Asking generic questions like “Explain Angular services”
✅ Ask project-aware questions instead

❌ Stopping MCP server
✅ MCP must stay running

❌ Expecting MCP to run the app
✅ That’s still ng serve

Try this 5-minute starter checklist

Do these in order:

Ask → Summarize this Angular project
Ask → What can be improved here?
Ask → Refactor one component safely
Review diff
Run app → ng serve

You’ll instantly feel the value.

https://medium.com/@ahfaz.rahman/integrating-angular-mcp-server-with-modern-ides-like-vs-code-and-cursor-84444b0abfad

https://angular.dev/ai/mcp

Google announced fully-managed MCP Servers for 4 services : BigQuery, GCE, GKE and Google Maps, with more to come in the future. If you'd like to get started with these, check out the tutorial: https://bit.ly/44Ux8jX

✅ How we got here
✅ Overview of the 4 MCP Servers announced
✅ Getting Started with BigQuery and Google Maps MCP Servers
✅ Detailed Google Cloud Project, Services and IAM setup
✅ Integrating with Gemini CLI

Let’s stay connected:

Instagram: https://www.instagram.com/angular_development/

Facebook: https://m.facebook.com/learnangular2plus/

Threads: https://www.threads.net/@angular_development

Medium: https://medium.com/@eraoftech

coderlegion: https://coderlegion.com/user/Sunny

Quora: https://neweraofcoding.quora.com/

YouTube: https://www.youtube.com/@neweraofcoding

LinkedIn: https://www.linkedin.com/company/infowebtech/

Hashnode: https://neweraofcoding.hashnode.dev/

GitHub: https://github.com/angulardevelopment/ | sunny7899

BlueSky: https://bsky.app/profile/neweraofcoding.bsky.social

Substack Newsletter: https://codeforweb.substack.com/

Pinterest: https://in.pinterest.com/tech_nerd_life/

dev.to: https://dev.to/sunny7899

Looking for web dev trainings: https://beginner-to-pro-training.vercel.app/

Software development services: https://infowebtechnologies.vercel.app/

Contribution to the web development community: https://code-for-next-generation.vercel.app/

Book a session: https://topmate.io/softwaredev

Telegram Channel: https://t.me/neweraofcoding

Thank you for being a part of the community. Happy coding!

Integrating Model Context Protocol with Gemini: The Definitive Guide to Modern Tool Calling

Thu, 14 Aug 2025 08:33:42 +0000

When it comes to tool-calling and agentic AI, the internet seems awash with tutorials for Anthropic’s Claude or the latest from OpenAI’s GPTs. But what if you want to ride the (less-documented) Gemini wave? If you’ve searched far and wide for a comprehensive guide on integrating the Model Context Protocol (MCP), Gemini, and modern tool schemas, only to find sparse blog posts tailored for other ecosystems, you’re not alone.

This tutorial fills that void, focusing on practical integration of Gemini and Model Context Protocol, from both server and client perspectives. We’ll draw on Node.js with TypeScript, @google/genai for Gemini and schema definition, and @modelcontextprotocol/sdk as our primary toolkit. By the end, you should be able registering tools server-side, and activate them client-side, all via MCP.

But before diving into code, let’s clarify a crucial foundation: what is Model Context Protocol?
MCP is an emerging open protocol standard for AI tool-calling, defining how AI models (clients) can discover and call arbitrary server-side tools, in a language and vendor-agnostic way (basically not dependent on the language used to develop server-side tools, or the AI model vendor). Think of it as the universal handshake between advanced AI clients and your server’s unique APIs or business logic. By using MCP, you unlock true interoperability: write a tool once, and access it from any AI that speaks the protocol.

Ready? Let’s dive in!

Setting Up Your AI Tooling Playground

Before we start, we need the 'ol 'getting started boilerplate'. This phase is all about laying down some groundwork, and covers initializing a project and installing the bare-metal essentials.

Step 1: Initialize Your Node.js Project

Crack open a terminal and create a fresh directory:

mkdir gemini-mcp-tutorial && cd gemini-mcp-tutorial
npm init -y

Step 2: Install Required Dependencies

You’ll need just four core libraries:

@google/genai: Official Google AI SDK (includes gemini, and other handy features like schema definitions for tool-calling).
@modelcontextprotocol/sdk: The heart of MCP communication (both server and client).
(Optionally) google-libphonenumber, if you want to parse phone numbers as we will in our example tool.

Install them in a single swing:

npm install @google/genai @modelcontextprotocol/sdk google-libphonenumber

If you’re using TypeScript (recommended), also install typing essentials:

npm install -D typescript ts-node @types/node

And, as with any journey, don’t forget to wire up your favorite Node.js (tsconfig.json and so forth).

Defining MCP Servers and Tools

With dependencies squared away, let’s architect both the server (which hosts our tools) and the client (which acts as a Gemini-empowered AI agent that calls them).

(A) Creating an MCP Server

Your MCP server will describe its tools and listen for tool-calling requests from clients. Let’s work from the skeleton up.

Start by defining the MCP server itself:

// src/mcp/server.ts
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';

const mcpServer = new McpServer({
  name: 'music-guys-mcp',
  version: '1.0.0',
  capabilities: {
    resources: {},
    tools: {},
  },
});

export default mcpServer;

Next, you’ll want to actually run this server and choose how it listens for requests. Here, we’ll use a simple stdio (Standard Input/Output) transport, which works beautifully for testing and local development:

// src/mcp/serverMain.ts
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import mcpServer from './server';

export const createServer = async () => {
  const transport = new StdioServerTransport();
  await mcpServer.connect(transport);
  console.info('MCP Server running on stdio');
};

createServer().catch((error) => {
  console.error('Fatal error in main():', error);
  process.exit(1);
});

Just like that, you’ve spun up an MCP-compliant tool server, ready for calls.

(B) Defining and Registering a Tool

Let’s register a real tool. Here’s a genuinely practical example: a tool that fetches user details by phone number. (We’ve stripped out some internal details, but you’re welcome to adapt as needed.)

// src/mcp/tools/getUser.ts
import mcpServer from '../server';
import { PhoneNumberUtil } from 'google-libphonenumber';

mcpServer.tool(
  'get-user-details',
  "Returns user details according to their phone number, or 'undefined' if user doesn't exist.",
  {
    phoneNumber: {
      type: 'string',
      description: 'User phone number including country code as registered.',
      required: true,
    },
  },
  async (args) => {
    const phoneNumber = args.phoneNumber;
    try {
      let formattedPhone = phoneNumber.startsWith('+')
        ? phoneNumber
        : `+${phoneNumber}`;
      const phoneUtil = PhoneNumberUtil.getInstance();
      const parsedNum = phoneUtil.parse(formattedPhone);

      // Here you'll implement your user lookup logic (e.g., using your database)
      // const user = ...;

      // For demonstration:
      if (parsedNum.getNationalNumber() === 1234567890) {
        // Mocked user:
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify({
                id: 'user-id',
                name: 'Jane Doe',
                phone: formattedPhone,
              }),
            },
          ],
        };
      }
      return {
        content: [
          {
            type: 'text',
            text: 'User not found',
          },
        ],
      };
    } catch (e) {
      return {
        content: [
          {
            type: 'text',
            text: `Failed to parse phone number: ${phoneNumber}: ${e}`,
          },
        ],
      };
    }
  }
);

And wire up your tool handler so it loads when the server starts (add this to the serverMain.ts file we've just defined above):

// src/mcp/serverMain.ts (add at the top)
import './tools/getUser';

Now, run your server with ts-node src/mcp/serverMain.ts, and it will listen for tool calls from any MCP-compatible client!

Implementing the MCP Client

At this point, we're half-way there. In this section, I'll walk you through on how to connect Gemini (or any MCP-aware model) to your server.

(A) MCP Client Bootstrap

First, let’s lay down the scaffolding for establishing the connection to the server (and to Gemini itself):

// src/mcp/client.ts
import { Client, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
import { GoogleGenAI } from '@google/genai';

export class MCPClient {
  private mcp: Client;
  private googleGenAI: GoogleGenAI;
  private tools: any[] = [];
  private transport: StdioClientTransport | null = null;

  constructor(apiKey: string) {
    this.googleGenAI = new GoogleGenAI({ apiKey });
    this.mcp = new Client({
      name: 'music-guys-mcp-client-cli',
      version: '1.0.0',
    });
  }

  // Connect through stdio to our running mcp server.
  async connectToServer(serverScriptPath: string) {
    const command = process.execPath;
    this.transport = new StdioClientTransport({
      command,
      args: [serverScriptPath],
    });
    await this.mcp.connect(this.transport);

    // Fetch available tools
    const toolsResult = await this.mcp.listTools();
    this.tools = toolsResult.tools.map(tool => ({
      functionDeclarations: [{
        name: tool.name,
        description: tool.description,
        parameters: tool.inputSchema,
      }],
    }));
    console.log('Available tools:', this.tools.map(t => t.functionDeclarations[0].name));
  }

  // Called via our chat loop, and is the main function that interfaces between tools and the Gemini model.
  async processQuery(query: string) {
    const response = await this.googleGenAI.models.generateContent({
      model: 'gemini-2.5-pro',
      contents: [
        {role: 'user', parts: [{text: query}]},
      ],
      // We've defined the list of tools that we have available and sent them as part of the request.
      config: {tools: this.tools, maxOutputTokens: 1024},
    });

    // Handle and display response, including any tool calls (see full method below for more)
    response.candidates?.forEach(cand =>
      cand.content?.parts?.forEach( async part => {
        const toolName = part.functionCall.name;
        const toolArgs = part.functionCall.args as
          | { [x: string]: unknown }
          | undefined;
        console.log('toolName', toolName);
        console.log('toolArgs: ', toolArgs);

        const tool = serverTools[toolName];
        if (tool) {
          const result = await tool.callback(toolArgs || {});

          contents.push({
            role: 'model',
            parts: [{text: (result.content as any)?.[0]?.text}],
          });

          if ((result.content as any)?.[0]?.text) {
            finalText.push((result.content as any)?.[0]?.text);
          }

          // call LLM to also get additional responses.
          const response = await this.googleGenAI.models.generateContent({
            model: this.modelName,
            contents: contents,
            config: {tools: this.tools, maxOutputTokens: 1024},
          });

          for (const candidate of response.candidates || []) {
            const content = candidate.content;
            for (const part of content?.parts || []) {
              if (part.text) {
                finalText.push(part.text);
              }
            }
          }
        }
      }));
  }
}

What is processQuery Doing?

This function is the heart of the Gemini+MCP client:
It orchestrates a conversation between the user, the Gemini model, and your set of tools (accessible via the Model Context Protocol).

The function does several key things:
TLDR;

Submits a user query to Gemini (with a list of available tools).
Inspects Gemini’s response to determine if a tool function needs to be called.
Invokes local/server tools when Gemini requests it (via a functionCall).
Feeds the tool results back into Gemini for a more complete or grounded answer.
Displays the final answer(s) to the user.

Here's a step by step breakdown for a clearer understanding

Sending the User Query to Gemini
```
const response = await this.googleGenAI.models.generateContent({
  model: 'gemini-2.5-pro',
  contents: [
 {role: 'user', parts: [{text: query}]},
  ],
  config: {tools: this.tools, maxOutputTokens: 1024},
});
```
- What’s happening here?
  You’re sending the user's question to Gemini’s generateContent() API.
- Why the tools in config?
  This tells Gemini, “Hey, here are the functions (‘tools’) I can call if you need them.”
- What does this let Gemini do?
  Gemini can, instead of answering directly, choose to call one of your tools if it thinks that’s appropriate (e.g. “get-user-details”).
Handling the Gemini Response (Including Tool Calls)
```
response.candidates?.forEach(cand =>
  cand.content?.parts?.forEach( async part => {
 ...
  })
);
```
- What’s happening here?
  Gemini may return several “candidates” (possible responses). Each candidate has “parts” which are chunks of its response, which could be text, images, or function calls.
- Why multiple loops?
  To handle all possible parts of all possible responses.
Detecting Function Calls (Tool Requests)
```
const toolName = part.functionCall.name;
const toolArgs = part.functionCall.args as { [x: string]: unknown } | undefined;
```
- What’s happening here?
  If Gemini thinks the answer requires calling a tool, it will return a functionCall instead of just text.
- toolName/toolArgs:
  These are the name and arguments for the requested tool.
Calling the Local/Server Tool with Those Arguments
```
const tool = serverTools[toolName];
if (tool) {
  const result = await tool.callback(toolArgs || {});
```
- What’s happening here?
  You look up (from your list of registered server tools) the one Gemini wants to call.
  - If it exists, you run it, passing the parsed arguments.
- This is where your server, database, or API logic runs.
Feeding the Tool Result Back to Gemini
```
contents.push({
  role: 'model',
  parts: [{text: (result.content as any)?.[0]?.text}],
});
```
- What’s happening here?
  After getting the tool’s output, you add it to the contents. This simulates Gemini’s internal dialogue and gives it the additional “real” data it just requested.
Asking Gemini for a Final Answer (Now Informed by the Tool Output)
```
const response = await this.googleGenAI.models.generateContent({
  model: this.modelName,
  contents: contents,
  config: {tools: this.tools, maxOutputTokens: 1024},
});
```
- What’s happening here?
  Now that Gemini has the tool output, you ask for another response. Gemini can now integrate that tool data and produce a final, well-informed answer.

Output the Final Result(s)

for (const candidate of response.candidates || []) {
  const content = candidate.content;
  for (const part of content?.parts || []) {
 if (part.text) {
   finalText.push(part.text);
 }
  }
}

What’s happening here?
Finally, you extract and print/return all the textual answers Gemini crafts after seeing the real data from your tool.

Why This Structure?

Two calls to Gemini:
First, to see if a tool call is requested; second, to let Gemini integrate the tool output into its answer.
MCP Tool Calling:
The magic of MCP+Gemini is this “AI calls your tools, you execute, and AI incorporates the result into its reasoning.”

(B) Running the Client Loop

Welcome to the interactive part. The chatLoop lets you query our Gemini model, who'll make the administrative decision on whether to call your MCP server’s tool as needed.

// src/mcp/runClient.ts
import { MCPClient } from './client';
// Ensure you have your Google API key ready
const API_KEY = process.env.GEMINI_API_KEY;

async function main() {
  const mcpClient = new MCPClient(API_KEY);
  await mcpClient.connectToServer(__dirname + '/serverMain.js');
  // Minimal chat/question loop
  process.stdin.setEncoding('utf-8');
  process.stdout.write("Ask your query or type 'quit':\n");

  process.stdin.on('data', async (input) => {
    const query = input.trim();
    if (query.toLowerCase() === 'quit') {
      process.exit(0);
    }
    await mcpClient.processQuery(query);
    process.stdout.write("\nAsk next query or 'quit':\n");
  });
}
main();

Now, simply run your client (ts-node src/mcp/runClient.ts), type in a phone number, or ask it to give you your details (as the get-user-details tool expects), and watch as Gemini seamlessly calls your custom tool!

Wrapping Up: What We’ve Built and Where You Can Go Next

Congratulations! You’ve now experienced end-to-end Model Context Protocol integration tailored to Gemini, spanning both a tool-hosting server and a tool-calling client.
Feel free to expand your tool arsenal by adding more business logic and tool endpoints (CRUD ops, APIs, complex workflows).
Have thoughts, questions, or wild new use cases? Drop a comment or issue below!
Happy contextual hacking!

Learn how to integrate Firebase AI Logic into your iOS app.

Sun, 08 Jun 2025 20:36:07 +0000

Implementing Firebase AI Logic in Your iOS App with Swift

Google Firebase has introduced AI Logic, a new way to build intelligent, dynamic behavior into your mobile apps using natural language prompts and structured logic—without needing to build or fine-tune your own models.

In this guide, we’ll walk through how to integrate Firebase AI Logic into your iOS app using Swift, from setup to implementation.

What Is Firebase AI Logic?

Firebase AI Logic is a managed service that allows you to define, test, and run AI-powered logic blocks using a mix of prompts and structured configuration. Think of it as serverless AI functions that take inputs, apply logic, and return structured outputs.

With AI Logic, you can:

Create logic using natural language prompts.
Call this logic from your iOS app using the Firebase AI SDK.
Use AI-generated decisions to personalize your UI, make recommendations, and more.

Requirements

Xcode 16.2+
iOS 15+ or macOS 12+
Firebase SDK v11.13.0+
A Firebase-connected app

Firebase Console Setup

Go to your project in the Firebase Console.
Under AI, select AI Logic.
Tap Start, then under Gemini Developer API, tap Start using this API.
In the dialog that appears, tap Enable. Wait until the API is enabled.
Click Continue to complete activation.

Enable App Check (Recommended)

To restrict API calls to authorized devices:

In the AI Logic panel, click Register on App Check.
In the App Check dashboard, click Start, then Register for the app you want to secure.
If your app supports only iOS 14+, you can register App Attest only. Otherwise, also register Device Check.
Complete all required fields and finish registration.

In the AI Logic dashboard, go to the APIs section.
Select Firebase AI Logic APIs, then click Apply to enforce App Check.

Enabling enforcement can take up to 30 minutes to propagate.

Enable App Transport Security Exception

In my case, I also needed to enable App Transport Security Exception.
To do this, go to Project → Signing & Capabilities → Add Capability → App Transport Security Exception.
Inside the capability, tap the + button and add googleapis.com.

Code Implementation

App Check

Add the Firebase App Check library to your project.
Create a file named AppCheckManager.swift:

import Firebase
import FirebaseAppCheck
 
final class AppCheckManager: NSObject, AppCheckProviderFactory {
 
public static let shared = AppCheckManager()
 
func createProvider(with app: FirebaseApp) -> AppCheckProvider? {
return AppAttestProvider(app: app)
}
 
public func setProviderFactory() {
#if DEBUG
 AppCheck.setAppCheckProviderFactory(AppCheckDebugProviderFactory())
#else
AppCheck.setAppCheckProviderFactory(self)
#endif
}
}

In your AppDelegate or main app file, before FirebaseApp.configure(), add:

AppCheckManager.shared.setProviderFactory()

In your Signing & Capabilities, add the App Attest entitlement.
In the generated .entitlements file, change the App Attest mode from development to production
To enable Firebase debug logging:
- Go to Product > Scheme > Edit Scheme…
- Select Run > Arguments
- Add a new argument: -FIRDebugEnabled

Run the app. You should see a log like this:

<Warning> [AppCheckCore][I-GAC004001] App Check debug token: '1E04B27F-15CD-46FA-862B-ED8E67841C9D'.

Copy this token, go to App Check > Apps in the Firebase Console, click the three dots next to your iOS app, choose Manage debug tokens, then add and save the token.

You're done setting up App Check.

Using Firebase AI Logic

Add the FirebaseAI package:

Go to General > Frameworks, Libraries, and Embedded Content
Tap the + button and add FirebaseAI

Simple Response

To generate a text response from a prompt:

import FirebaseAI
 
func callAI() async {
do {
let prompt = "Your prompt here..."
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
let model = ai.generativeModel(modelName: "gemini-2.0-flash")
let response = try await model.generateContent(prompt)
 
if let answer = response.text {
print("FirebaseAI response:", answer)
}
} catch {
print("FirebaseAI error:", error)
}
}

Streamed Response

For a more responsive UI, stream partial results as they’re generated:

func aiStrem() async {
do {
let prompt = "Your prompt here..."
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
let model = ai.generativeModel(modelName: "gemini-2.0-flash")
let response = try model.generateContentStream(prompt)
 
for try await chunk in response {
if let text = chunk.text {
print("FirebaseAI text:", text)
}
}
} catch {
print("FirebaseAI error:", error)
}
}

Troubleshooting

HTTP 403 Errors

If you see a 403 error:

Go to the Google Cloud Console
Select your Firebase project
Navigate to APIs & Services > Credentials
Find your iOS key, click it
Ensure Firebase AI Logic API is enabled under API Restrictions. If not:
- Select it
- Click Save
- Wait up to 30 minutes before retrying

If the error persists:

Temporarily switch to “Don’t restrict key” mode to test.
You may also try disabling and re-enabling App Check for Firebase AI Logic.

Conclusion

Firebase AI Logic allows iOS developers to integrate intelligent logic blocks into apps without the need to manage ML models or infrastructure. With App Check, you can keep API access secure, and with just a few lines of Swift, you can call or stream AI responses to build truly dynamic user experiences.

Thanks for reading! If you have questions or want a complete sample project, feel free to reach out or leave a comment.

Coder Legion - Recent posts tagged gemini

I Built ArchShield: An AI Architecture & Security Baseline Assistant.

What I Built

Demo

My Experience

Most people use AI wrong: Stop pasting raw links and hoping for magic.

buildinpublic #AI #productivity #ChatGPT #Claude #ChromeExtension #PKM

Copy-pasting research into ChatGPT, Claude, or Gemini is broken!

buildinpublic #AI #productivity #ChatGPT #Claude #ChromeExtension #PKM

Gemini 3.1 Pro Is Gone From My Antigravity Model Selector. Here's What I Can (and Can't) Confirm

1. What's Confirmed, and What Isn't

2. A Pattern, Not a One-Off

3. What My Own Experience Adds, and What It Doesn't

4. Notes on 3.8 Flash (High) for Web Development

5. The Other Side

6. What I'd Do Now

A Question for You

Sources & References

AudioFlow- STT and TTS tool

Building a Real-Time Social Listening & Brand Sentiment Engine with Python, Gemini 1.5, and DuckDB

1. The Architecture

Core Pillars:

2. Ingestion & Deduplication via DuckDB

3. Structured Gemini 1.5 Flash Evaluation

The Evaluation Schema

Inference Function with Enforced JSON Schema

4. Threshold Alerting & Webhook Routing

5. Deployment, Concurrency & Rate Limits

The Concurrency Pool Pattern

Analytical Daily Rollups via DuckDB

6. Conclusion & Turnkey Template

ChatGPT, Claude, Gemini, or Cursor? Which AI Tool Is Your Go-To and Why?

ChatGPT, Claude, Gemini, or Cursor? Which AI Tool Is Your Go-To and Why?

The Developer's Usual Suspects

Join the Discussion!

Google confirmed Gemini accessed 3 live corporate systems during a red-teaming test

The Stateless Inference Pipeline: Ephemeral Payloads and Quota Metadata

The Stateless Inference Pipeline: Ephemeral Payloads and Quota Metadata

End-to-end flow (accurate)

What may persist server-side

Model routing and attachments

Streaming

Procurement questions this answers

Antigravity CLI First Impressions: Fast, Rough, and Not Ready

What I tested

First-run impressions

Flash versus the CLI

Quota and value

Recommendation

From Chatbots to Coworkers: What Google Cloud Next '26 Means for Developers

The Agentic Enterprise Blueprint

Gemini Enterprise Agent Platform (The Vertex AI Rebrand)

What's Actually Shipping

The AI Hypercomputer: 8th-Gen TPUs

Agentic Data Cloud: From Passive Storage to System of Action

Agentic Defense: The Wiz Integration Goes Live

The Agentic Taskforce: Companies Already Shipping

Prompt Grounding in a Stateless World

Prompt Grounding in a Stateless World

Layer 1 — SYSTEM_PROMPT (persona + guardrails)

Layer 2 — Portfolio context block

Layer 3 — Live quote injection (extractSymbolHints)

Layer 4 — Attachments (paid)

Provider routing

Why 10k CSV rows never hit the model (default path)

The Anthology of a Creative Developer: A 2026 Portfolio

The Prologue: Beyond the "Sectioned Resume"

The Gallery

The Craft (How I Built It)

The Technical Spine

The Editorial Vision

Google AI: The Creative Director

The "Director's Cut" (What I'm Proud Of)

Closing Thoughts

Customizing Azure Cloud Shell for Cross Cloud Development

canonical_url: https://xbill999.medium.com/customizing-azure-cloud-shell-for-cross-cloud-development-5af464de14ab

What is Gemini CLI?

Azure Cloud Shell

Why would I want Gemini CLI on Azure? Isn’t that a Google Thing?

Activating Azure CloudShell

Layer 1 — `SYSTEM_PROMPT` (persona + guardrails)

Layer 3 — Live quote injection (`extractSymbolHints`)