How I debloated a Xiaomi Android TV in one evening, without rooting it and without uninstalling anything, using an open-source repo and an AI coding agent.

My TV is a Xiaomi Mi TV 4A Pro (the model string is MiTV-AXSO0) running Android TV 9. It works fine, but every time I turned it on, the first thing I saw was an advert.

This is what the home screen looked like before I started:

The top half was a rotating hero banner, often marked Sponsored. Below that was a PatchWall tile, Xiaomi’s own content hub. Below that came rows of “recommendations” that were mostly promotions. In the background, Xiaomi analytics, a “statistics” service, a cleaner app nobody asked for, a sponsored TV guide and a partner-app auto-installer were all running.

I wanted three things:

1. Get rid of the ads and the telemetry without breaking HDMI, Live TV, the remote, or the streaming apps my family actually uses.

2. Replace the home scree with something clean: black, calm, my apps and nothing else.

3. Be able to undo all of it.

Here’s how it went.

The tools: an open-source repo plus an AI agent

I used [CleanYourTV](https://github.com/Gathin23/cleanyourtv), an open-source project that does two things:

- It keeps tested debloat lists for specific TV models. Each list is a plain text file of package names, with comments explaining what each one is.

- It ships a small native Android TV launcher, written in plain Java with no internet permission, that looks a lot like the Apple TV home screen.

The repo also has a long prompt (`PROMPT.md`) that you give to an AI coding agent. I used Claude Code on my Windows laptop, pasted that prompt in, and the agent did the work over ADB (Android Debug Bridge) on my home Wi-Fi. It asked me before anything that depended on my preferences.

What I liked most is that the safety rules are built into the scripts, not left to the agent’s judgement:

- Disable, never uninstall. Every change is `pm disable-user`, which can be reversed with `pm enable`. Nothing is uninstalled, rooted or flashed.

- Back up first. The full package list, the list of already-disabled packages, all system properties and every system setting get saved to a folder on your PC before anything changes.

- Core Android packages are untouchable. The scripts refuse to run a list that includes things like the package installer or the permission controller.

• Don’t open factory menus, not even to look. On some boards that flips a flag the shell can’t undo.

🛠️ Step 0: Set Up Your Computer

Before we get started, let’s prepare your computer.

You’ll need a computer connected to the same Wi-Fi network as your Android TV. I used a Windows laptop for this setup, but macOS and Linux should work too.

1. 📦 Install the Required Tools

We’ll need a few tools to clone the project, interact with the TV, build the Android launcher, and run our AI coding agent.

Here’s what each tool does:

1. 📦 Install the Required Tools

Before we begin, make sure you have the following tools installed:

• 🐙 Git — To clone/download the project repository from GitHub.
• 💻 VS Code — To open the project, edit files, and run commands in the integrated terminal.
• 🐍 Python 3 — To execute the TV automation scripts and Python-based tools.
• 🔌 Android Platform Tools (ADB) — To communicate with your Android TV over the network.
• 🤖 Android Studio — To get the Android SDK required to build the custom launcher.
• ☕ JDK 17 — Required to compile and build the Android launcher.
• 🧠 AI Coding Agent (Claude Code) — To understand the project, execute commands, and automate the setup process.

💡 Tip for Windows users: You can install most of these tools directly from PowerShell or Windows Terminal using winget.

Run the following commands:

winget install Git.Git

winget install Microsoft.VisualStudioCode

winget install Python.Python.3.12

winget install Google.PlatformTools

winget install Google.AndroidStudio

winget install EclipseAdoptium.Temurin.17.JDK

Once Android Studio is installed, open it at least once. This allows it to download and configure the required Android SDK.

You won’t need to use Android Studio regularly after this initial setup.

2. 📥 Clone the Repository and Open It

Now that our development environment is ready, let’s download the project.

Open your terminal and execute:

git clone https://github.com/Gathin23/cleanyourtv

cd cleanyourtv

code .

This downloads the repository, navigates into the project directory, and opens it in VS Code.

⚠️ Important: Run your AI coding agent from inside the cloned repository.

This is more important than it might seem!

The repository already contains scripts such as:

• tools/disable.sh
• The launcher’s installation script
• Backup and recovery mechanisms
• A protected-package list
• Safety checks that prevent disabling the stock launcher before the new launcher is working.

These safeguards are already implemented in the project.

By running the AI agent from inside the repository, it can understand and reuse the existing scripts instead of creating everything from scratch.

What about Python dependencies?

No need to install Python packages manually!

On its first run, the agent creates a virtual environment inside tools/venv and installs the required dependencies from the repository's requirements file.

3. 📝 Locate the Main Prompt

We’re almost ready!

The main instructions for the AI coding agent are stored in a file called PROMPT.md, located in the root directory of the repository.

If you’re using VS Code:

1. Look at the Explorer panel on the left.
2. Find PROMPT.md.
3. Open the file.
4. Review the instructions that will guide the AI agent through the setup.

This file is important because it tells the agent what needs to be done and how to interact with your Android TV safely.

In the next step, we’ll use this prompt to get the AI agent working on the TV setup.

Start the agent and paste the Prompt-

Open a terminal in the repo folder (in VS Code: Terminal → New Terminal), start the agent (claude for Claude Code) and paste the copied prompt.

🎯 That’s it for Step 0! Your computer is ready, the repository is cloned, and all the required tools are in place.

Let’s move on to the interesting part: letting the AI agent take over!

🔧 Step 1: Enable Debugging, Connect, and Back Up

Now that our computer is ready, it’s time to connect to the Android TV.

We’ll use ADB (Android Debug Bridge) throughout this process. ADB is the same tool Android developers use to communicate with and manage Android devices.

By default, ADB debugging is disabled on Android TV. We’ll first enable Developer Options and USB Debugging using the TV remote.

1. 🔓 Unlock Developer Options

Let’s start on your Android TV:

1. Open Settings (the ⚙️ gear icon).
2. Navigate to Device Preferences → About.
3. Scroll down to Build.
4. Select Build using your remote and press the OK button seven times.

After a few presses, you’ll see a countdown message.

Once completed, you should see:

🎉 “You are now a developer!”

📸 Settings → Device Preferences → About. The Build option is usually further down the list.

2. 🐞 Enable USB Debugging

Now that Developer Options are unlocked, let’s enable debugging.

1. Press the Back button on your remote once.
2. Open Device Preferences → Developer Options.
3. Scroll down to the Debugging section.
4. Find USB Debugging and switch it ON.
5. Confirm the warning message when prompted.

✅ That’s it! USB Debugging is now enabled, allowing your computer to communicate with the TV through ADB.

3. 🌐 Connect to the TV Over Wi-Fi

Despite its name, USB Debugging on my Mi TV also enables ADB over the network on port 5555.

This means you don’t need a USB cable! Your laptop and TV just need to be connected to the same Wi-Fi network.

💡 Note: Some TVs have a separate Network Debugging or ADB over Network toggle on the same screen. Newer Google TV devices may offer Wireless Debugging, which requires pairing using a code.

4. 📍 Find Your TV’s IP Address

On your Android TV, navigate to:

Settings → Network & Internet → Your connected Wi-Fi network

Here, you’ll find the TV’s IP address.

💡 In my case, the AI agent discovered the IP address automatically from my laptop, but it’s handy to know where to find it.

5. 🔐 Accept the Connection Prompt

The first time your computer connects to the TV, a permission prompt will appear on the TV screen.

• Select Always allow from this computer.
• Choose Allow using your TV remote.

✅ That’s it! Your computer is now authorized to communicate with your Android TV through ADB.

If you don’t press OK, nothing can connect. That’s the main protection ADB has, and it’s why you should revoke these authorisations and switch debugging off again when you’re done (Step 6).

6. 💾 Back Up Your TV

With the connection established, the AI agent discovered my TV on the network and connected through ADB on port 5555.

Before making any changes, it created a backup of the TV’s existing configuration, including:

• 📦 All 113 installed packages.
• 🚫 The 3 packages that were already disabled.
• ⚙️ Complete getprop output.
• 🔧 All global, secure, and system settings.
• 🖥️ Display size and density.
• 🏠 The currently configured Home app (launcher).

One more interesting discovery! The repository already contained a tested package list for my exact TV model and firmware:

• Board: dangal
• Build: PI.6036

This was important because the package list had already been tested on the same TV model and firmware. So, we weren’t relying on guesswork when deciding what could safely be disabled.

✅ Backup complete! Now we have a snapshot of the original configuration before making any changes.

🧹 Step 2: Debloat in Small Batches

Before disabling anything, the AI agent grouped the installed packages and asked me which streaming apps and services I actually use.

I kept Netflix, Prime Video, YouTube, JioHotstar, Google Assistant, Chromecast, screen mirroring and the firmware updater. Anything I wasn’t sure about stayed enabled.

The agent then disabled 17 packages across three small batches, taking a screenshot after each batch to make sure nothing had broken.

📦 Batch 1: Telemetry

• Mi TV Analytics and Xiaomi Statistics.
• Google Feedback and Bug Report Sender.

📺 Batch 2: Ads & Content Rows

• PatchWall.
• Xiaomi Web Content Service and Floating Frame.
• Google TV Recommendations.
• Mi TV+ sponsored live channels.
• Sensara sponsored TV guide.
• Play auto-installer for partner apps.

🧹 Batch 3: Background Clutter

• TV Manager (cleaner app).
• Handbook and legal-text screens.
• Mi Music and Mi Gallery.

🔍 One Interesting Discovery

After Batch 2, the PatchWall tile disappeared, but the Sponsored banner was still there.

It turns out that the banner comes from Google’s stock launcher itself. Removing it required replacing the launcher — which was exactly what we planned to do next!

🔄 Verify After Reboot

One important detail: Android writes package-state changes to disk roughly 10 seconds after a change.

Rebooting too quickly can make it appear as though the firmware has re-enabled the disabled packages.

To avoid this, the agent ran sync, rebooted the TV, and compared the disabled-package list before and after.

✅ All 17 packages remained disabled!

🏠 Step 3: Meet the New Home Screen

Now comes the exciting part! Let’s replace the stock Android TV launcher with the CleanYourTV launcher.

The launcher is lightweight, approximately 575 KB, and designed for TVs with limited memory.

It comes with:

• 🚫 No network access
• 🔄 No background polling
• 🌫️ No blur effects
• 🎬 No video playback

The installation script takes care of everything:

1. Builds the launcher.
2. Installs it on the TV.
3. Sets it as the default Home app.
4. Confirms that the new launcher is working.
5. Only then disables the stock launcher.

🔐 Safety first: The old launcher won’t be disabled until the new one is confirmed as the active Home app.

✨ What Does the New Launcher Offer?

• 📱 App Dock: Your four apps displayed in a slightly lighter, rounded band.
• 🎨 Dynamic Ambient Glow: The focused app’s name appears in large text, with a soft glow inspired by its banner colour.
• 💎 Glass Highlight: A smooth, spring-like highlight that moves from one app tile to another
• ⚙️ Quick Settings: Frosted-glass buttons for Inputs, Wi-Fi and Settings in the top-right corner.
• 📺 Inputs Dropdown: Quick access to HDMI 1–3, AV and Live TV.

The agent then tested the D-pad from every edge. Down moves exactly one row. Up from the dock goes to the top bar. The ends of the top bar don’t wrap around onto the tiles. And after a reboot, the TV now starts straight on the new home screen.

One build hiccup worth mentioning: Android Studio’s bundled JDK 25 was too new for the project’s Gradle version. A portable JDK 17 fixed it.

Step 4: The remote, which needed testing by hand

This is the part I’d tell anyone doing this to pay attention to. Keys injected over ADB don’t prove the real remote works. The agent asked me to press each physical button, and recorded what the TV received while I did:

- The Mi button is a normal Home key. It works.

- Netflix, Prime, mic all still work.

- One button, the one that used to open PatchWall, now did nothing. It sends keycode 192, and a Xiaomi system service sends that to PatchWall, which we had disabled.

At first I left it dead, which is the safe choice. Then I had a better idea.

🎃 Step 5: Making It Spooky — Halloween Theme & Bat Button

The default launcher looked a little too plain for my taste, so I decided to explore the themes available in the repository.

And there are plenty to choose from! Around 20 themes, including:

• 🍎 Aerial: Apple TV-style wallpapers featuring photographs taken from the International Space Station.
• 💎 Frosted Glass: A sleek glass-inspired appearance.
• 🌌 Aurora: Beautiful aurora-inspired visuals.
• 🎮 Pixel Art: Retro pixel-art landscapes.
• 🎃 Seasonal Themes: Special themes for different occasions.

I decided to go with Halloween!

🦇 A Little Halloween Customization

Themes are managed using a simple config.json file along with wallpapers. You can push them directly to the TV with a single command. No rebuild required!

Since the theme’s festive mode had officially ended on 1 November, I created a personal copy and extended its end date to the 30th.

Here’s what changed:

• 🎃 Wi-Fi: The Wi-Fi pill becomes a glowing jack-o’-lantern when connected.
• 🦇 Inputs: Replaced with a bat icon.
• 👻 Settings: Replaced with a ghost icon.
• 🎉 Greeting: Displays “Happy Halloween”.
• 🌕 Wallpapers: Rotates between haunted houses, jack-o’-lanterns, full moons and foggy cemeteries.
• 🦇 Daily Surprise: The first time you press Home each day, a flock of bats flies across the screen!

Now that’s a home screen with some personality! 👻

🦇 Giving the PatchWall Button a New Job

Once a day wasn’t enough! I wanted to trigger the bat animation whenever I wanted.

So, I repurposed the unused PatchWall button on the remote. Now, pressing it makes bats fly across the screen, even while using YouTube!

🔧 How did it work?

• Added a new bats action alongside existing actions like home, mute, and screensaver.
• Mapped the PatchWall button to this new action.

It works through the launcher’s key helper, an accessibility service that intercepts remote button presses before Xiaomi’s system service handles them.

🎃 One more reason to love this custom launcher!

🔒 Step 6: Lock the Door Behind You

One important step that’s easy to forget: disable ADB debugging once you’re done.

ADB on port 5555 is unencrypted while enabled, meaning other devices on your home network could potentially access your TV.

Here’s what I did:

1. Go to Settings → Device Preferences → Developer Options → Revoke USB debugging authorisations.
2. Turn OFF USB Debugging and Network Debugging, if available.
3. Restart the TV via Settings → Device Preferences → About → Restart.

The repository’s checker then confirmed the final configuration.

🎉 What I Ended Up With

• 🚫 17 packages disabled — telemetry, ads and unnecessary clutter. Nothing was uninstalled.
• 📺 No sponsored banners or PatchWall when the TV starts.
• 🍎 A clean, Apple TV-inspired home screen with my four favourite apps.
• ✅ HDMI, Live TV, Chromecast, microphone and streaming apps still working.
• 🦇 A dedicated bat button on the remote!
• 💾 A backup and restore script, plus a README explaining how to re-enable apps, change the dock and swap wallpapers.

💡 A Few Tips Before You Try It

• 🔍 Check the repository’s examples/ folder for your TV model. A tested package list makes the process much safer.
• 🛡️ Make changes in small batches, keep your backup, and test the physical remote afterwards.
• 🔒 Disable ADB when you’re finished. Don’t leave debugging enabled unnecessarily.

And that’s it! A cleaner, lighter and more personalised Android TV experience without uninstalling anything or breaking the features I use every day.

The project is open source and MIT-licensed:

github.com/Gathin23/cleanyourtv. Thanks to everyone who has contributed tested lists for their TVs. Mine only took one evening because someone else had already worked out which packages were safe on this exact model.

A big thank-you to Gathin, who created CleanYourTV (github.com/Gathin23/cleanyourtv), for building a tool that turned an ad-filled TV into something I actually enjoy switching on. This was genuinely fun to do, bats and all. 🦇

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Searching job portals every day is repetitive. Instead of manually opening LinkedIn, Indeed, and company career pages, why not let an AI agent do the searching, analyze every posting, rank them against your skills, and deliver the best matches directly to your inbox?

If you’ve looked at UiPath’s newer “coded agents” and wondered how they actually fit together with LangGraph, Pydantic, and the rest of the Python AI ecosystem, this tutorial walks through a complete, working example: an AI Job Hunter agent.

Give it a role, some keywords, and your skills — it searches the web for matching postings, has an LLM read and score each one against your profile, removes duplicates, and hands you back a polished .xlsx report (with an optional email delivery on top).

Why LangGraph?

Instead of placing everything inside main.py, the project separates responsibilities across multiple modules:

• config.py manages configuration.
• models.py defines the application's data contracts.
• firecrawl_tools.py handles job discovery and scraping.
• workflow.py orchestrates the complete AI workflow.
• excel_utils.py generates the final report.

This modular design makes the project easier to maintain, debug, and extend.

What we’re building

The agent is a four-step LangGraph pipeline:

• discover_jobs — searches and scrapes job postings using Firecrawl.
• analyze_jobs — sends each posting to an LLM (through UiPath's LLM Gateway) and gets back a structured, Pydantic-validated JobAnalysis object: title, company, required skills, a 0–100 match score, and a short explanation.
• export_results — deduplicates by application URL and writes everything to a styled Excel workbook.
• send_email — optionally delivers an HTML summary plus the workbook as an attachment through a UiPath AgentHub MCP mail server.

Prerequisites

🚀 Getting Started in Your Environment

Getting the project up and running is straightforward. Before you begin, make sure you have the following installed:

• 🐍 Python 3.11–3.13
• 🌿 Git
• ⚡ uv (used to manage project dependencies)
• 🤖 UiPath CLI
• ☁️ A UiPath Automation Cloud account

Getting Started in your environment

Clone the Repository

Start by cloning the repository and installing the project dependencies:

💡 Tip: You’ll find the repo link at the bottom of this article.

git clone https://github.com/AJYoutube007/JobHunter_Agent.git
cd JobHunter_Agent
uv sync

Create a UiPath Studio Workflow for Sending Emails

Create a simple UiPath Web Studio workflow that sends emails using the Gmail Integration activities. The workflow should accept inputs such as the recipient’s email address, subject, email body, and an optional attachment.

Once the workflow is tested successfully, publish it to UiPath Orchestrator and expose it as an MCP tool. This allows the AI Job Hunter Agent to call the workflow whenever it needs to email the job summary and Excel report.

Configure Your Environment

Next, create your environment file by copying the sample configuration:

cp .env.example .env

Open the .env file and add your Firecrawl API key along with any other required settings.

FIRECRAWL_API_KEY= # You can get it from https://www.firecrawl.dev/

# These are generated automatically once you run `uipath auth` or `uipath init`

UIPATH_ACCESS_TOKEN=
UIPATH_URL=
UIPATH_TENANT_ID=
UIPATH_ORGANIZATION_ID=
FIRECRAWL_API_KEY=
UIPATH_MODEL=gpt-4o-mini-2024-07-18
OUTPUT_DIR=output
FIRECRAWL_LIMIT=10

# Studio workflow: build a flow that sends emails via the Gmail integration,
# then expose it through UiPath as an MCP tool

UIPATH_MCP_SERVER_URL=

Once that's done, authenticate with UiPath using:

uip login

Try It Without Live Data (Demo Mode)

If you’re just exploring the project, you don’t even need a Firecrawl API key. Enable Demo Mode, and the agent will generate sample job data so you can experience the full workflow without making any external API calls.

Run a Real Job Search

When you’re ready to search for real jobs, update input.json with your preferred job title, locations, skills, and experience, then run the agent via the UiPath CLI. The agent will search for jobs, analyze each posting with AI, and generate a neatly formatted Excel report of the best matches.

Deploy to Orchestrator

Once you’ve successfully run the agent locally, the next step is deploying it to UiPath Orchestrator so it can be managed and executed in an enterprise environment.

Package and publish the project using the UiPath CLI:

uip pack
uip publish

That’s it! In just a few minutes, you’ll have your own AI-powered Job Hunter Agent running locally.

Step 1: Define Strong Data Models (models.py)

Instead of passing dictionaries between workflow nodes, the project uses Pydantic models defined in models.py.

The key models include:

• CandidateProfile — stores candidate skills and experience.
• JobHunterInput — represents the agent input.
• JobAnalysis — represents the AI-generated analysis for each job.
• Workflow State — shared state between LangGraph nodes.

Using strongly typed models improves validation and keeps each workflow node predictable.

Step 2— Keep AI Prompts Separate (prompts.py)

Prompt engineering is isolated inside prompts.py.

Rather than embedding prompt text throughout the workflow, all AI instructions are centralized in one location.

This makes prompts easier to:

• improve
• maintain

without changing the workflow logic.

# prompts.py
"""Prompts are isolated to make production tuning auditable."""

from .models import CandidateProfile


def job_analysis_prompt(document: str, url: str, profile: CandidateProfile) -> str:
    return f"""You are an exacting job-posting analyst. Extract only facts supported by the posting,
then assess fit for the candidate. Do not invent salary, dates, skills, or remote status.

Candidate profile:
- Skills: {', '.join(profile.skills) or 'not provided'}
- Years of experience: {profile.years_experience if profile.years_experience is not None else 'not provided'}
- Summary: {profile.summary or 'not provided'}

Apply URL (use this exact URL if the posting does not provide a better application URL): {url}

Posting:
{document[:24000]}

Return the requested structured fields. Match score is 0-100. Explain the score concisely and
identify missing critical requirements in notes. Set status to New."""

Step 3— Discover Jobs (firecrawl_tools.py)

The firecrawl_tools.py module communicates with Firecrawl.

Instead of scraping a single job portal, it performs web searches using dynamic search queries.

For example:

Senior UiPath Developer Remote India

Firecrawl then:

• searches the web
• scrapes relevant pages
• returns markdown
• resolves job URLs

Because Firecrawl searches the open web, the project isn’t tied to any specific job board.

Step 4— Analyze Jobs with AI (workflow.py + prompts.py)

The heart of the application is workflow.py.

This file defines the LangGraph workflow responsible for orchestrating every step.

For each discovered job:

1. The description is collected.
2. The prompt from prompts.py is used.
3. The LLM extracts structured information.
4. A JobAnalysis object is returned.

The AI extracts information such as:

• Job Title, Company, Experience, Skills, Summary, Match Score, Apply URL

Instead of returning unstructured text, the LLM produces validated structured data.

Step 5— Resolve Direct Job URLs (firecrawl_tools.py)

Search engines often return listing pages rather than actual job postings.

The project detects these situations and uses additional Firecrawl searches to locate the direct application page.

If no valid application URL can be resolved, the listing is skipped.

This keeps the final report clean and prevents broken links.

Step 6— Export Results (excel_utils.py)

Once analysis is complete, excel_utils.py creates a formatted Excel workbook.

Each row includes:

The workbook is automatically formatted with readable headers, filters, and styling so it’s immediately ready for use.

📬 Expected Output

Once the workflow completes, you’ll receive a polished HTML email summarizing the best matching jobs, along with a formatted Excel report containing complete job details and direct application links.

Sample output:

📘 Reference:

You can copy the whole Agent from my GitHub page:

GitHub - AJYoutube007/JobHunter_Agent

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Best of luck and happy automating! 🤖💫

When UiPath announced extension support in Studio 26.0.195, my first question was simple:

Can I install actual VS Code extensions inside UiPath Studio?

The answer is yes.

UiPath Studio now supports VSIX packages, which means many extensions from the VS Code ecosystem can be installed directly into Studio. To see how far this could go, I decided to experiment with a few completely different extensions — from a mini game, to an AI coding agent, to PDF and Word document viewers.

All extensions can be discovered, installed, and managed from the new Extensions panel in UiPath Studio.

Here’s what I tried first.

Extension #1: OpenAI Codex Inside Studio 🤖

The first extension I installed was Codex.

Instead of switching between Studio and an external AI tool, I could interact with an AI coding agent directly from my automation development environment.

Whether it’s generating logic, explaining code, reviewing workflows, or helping troubleshoot issues, having an AI assistant available within Studio creates a much smoother development experience.

Extension #2: Keeping Project Documentation Inside Studio 📄

Every automation project comes with documentation.

PDDs, business requirements, solution design documents, test cases, sample invoices, input spreadsheets, and process notes are constantly referenced during development.

To solve this, I installed two extensions:

• vscode-pdf for viewing PDF documents
• Office Viewer for opening Word, Excel, and PowerPoint files

With these extensions, project documentation can be opened directly inside UiPath Studio. Whether it’s reviewing a PDD, checking an input spreadsheet, or validating business rules in a Word document, everything remains available alongside the workflow being developed.

This is one of those features that immediately feels useful after trying it.

One thing I discovered while testing these extensions is that PDF, Word, Excel, and other non-automation files may not appear in the Explorer panel by default.

Important Note: Click the Filter icon and enable Other under file types.

Results after the installation of extension

Extension #3: Testing APIs with Postman 🔌

APIs are at the heart of modern automations, and the Postman extension brings API testing directly into UiPath Studio.

Instead of switching between applications, you can validate endpoints, test authentication, inspect responses, and verify payloads before implementing HTTP Request activities.

While I encountered an authentication issue during testing, the ability to test APIs from within Studio highlights the potential of the new extension ecosystem and a more integrated development experience.

Extension #4: Playing Games Inside UiPath Studio 🎮

Now for the extension I definitely wasn’t expecting.

I installed a mini-game extension and suddenly found myself playing games inside UiPath Studio.

While this won’t help deliver automations faster, it perfectly demonstrates the flexibility of the new extension framework.

The fact that Studio can host everything from AI coding assistants to document viewers — and even games — shows how much the platform has evolved.

And let’s be honest: every developer deserves a quick break while waiting for a package restore.

Here are the results:

Final Thoughts

UiPath Studio Extensions may seem like a small feature, but they have the potential to significantly improve the developer experience.

From AI assistants and API testing to project documentation and even a few fun extras, extensions make it easier to keep everything in one place.

I’m excited to see how the community adopts this feature and what extensions become must-haves for automation developers.

Which extension are you trying first?

📘 Reference:

UiPath 26.0.195 June Community Release

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Best of luck and happy automating! 🤖💫

AI coding assistants are great — until you ask them to build a UiPath automation.

That’s when things start to fall apart.

The model confidently generates workflows, references activities that sound perfectly valid, and produces code that looks right… but fails instantly. Activities don’t exist. Package behavior is guessed. And suddenly you’re debugging fiction instead of automation.

The problem isn’t the model — it’s the ecosystem.

UiPath is highly specialized. It combines XAML workflows, activity packages, orchestrator interactions, and now coded automations. This structure doesn’t translate cleanly into the kind of generalized patterns most AI models are trained on. So the model fills in the gaps with assumptions — and those assumptions break things.

That’s where UiPath Agent Skills comes in.

UiPath Agent Skills is UiPath’s official answer to this gap. It’s an open-source collection of structured “skills” that you plug directly into your AI coding assistant. Instead of guessing, the model now has grounded knowledge of real activities, APIs, and patterns.

And the best part? It’s incredibly simple to use.

Two commands — and your AI goes from “creative but unreliable” to “actually useful.”

What is a “skill” in this context?

In the UiPath Agent Skills repo, a skill isn’t a library — it’s a structured instruction file (SKILL.md) for your AI agent. It tells the agent exactly how to perform a UiPath task: which activities to use, required parameters, project structure, CLI commands, and common pitfalls.

Think of it as a focused briefing that removes guesswork.

This approach is increasingly common in agentic tools like Claude Code and Cursor IDE, which load project-specific rules. UiPath skills plug into that same idea — giving your AI a practical, grounded understanding of UiPath development.

🧰 Prerequisites

Before you start, make sure you have:

🟢 Node.js (LTS)
Verify with node -v — no version = install it first

🤖 UiPath Studio
For building and running automations with Terminal

🧠 AI Coding Agent
Claude Code, Cursor IDE, Codex CLI, or Gemini

Step 1: Install Node.js

Verify with node -v — no version = install it first

To Install Node.js (LTS) using Winget:

winget install OpenJS.NodeJS.LTS

Verify with node -v

Step 2 : Install UiPath Cli

npm -g install @uipath/cli

This command installs the UiPath CLI globally on your machine.

• npm → Node package manager (comes with Node.js)
• -g (global) → Installs the package system-wide (usable from anywhere in terminal)
• @uipath/cli → Official UiPath CLI package

✅ Verify Installation

Now if you run: uip

You should see the UiPath CLI help menu.

Step 3: Install Skills

Now we can install the AI skills:

uip skills install

You can install all the skills in my Tutorial i have only install the Gemini CLI, You can use any agent that you prefer.

After Skills installation we also need to link these skills to our Gemini cli agent

If Gemini cli is not already installed

npm install -g @google/gemini-cli

you can also check my other article where i have mention all the detail steps for gemini link

Step 4: Link those skills With Agent

Skills are installed at the user profile level when you run the UiPath CLI command uip skills install.
These skills are stored at for example : C:\Users\Abhishek\.uipath\.skills\skills

To use them with the Gemini CLI, you must link this directory so Gemini can recognize them as native skills.

You can see the whole skills list in the gemini cli

Step 5: Give it a Try

Now you are all set to use these skills inside UiPath Studio.

To try it out, I went with something fun and gave this prompt:

> create a simple number guessing game using uipath-rpa skills take input & then give output in loop until correct, make it fun logical game in main.xaml

The results were impressive — the system generated a complete, runnable workflow.
It handled input, implemented a loop until the correct guess, added logical conditions, and produced structured output — all directly usable in Main.xaml.

If you’re already using tools like Cursor IDE or Claude Code, this is one of the easiest upgrades you can make.

Two commands — and your AI goes from guessing to building.

📘 Reference:

If you’re building automations on UiPath and using any AI coding assistant, this repo deserves a look.

GitHub - UiPath/skills: This is a repository of skills for interfacing UiPath capabilities to external developers.

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Best of luck and happy automating! 🤖💫

For years, UiPath Studio has been a powerful IDE for building enterprise automations. But one thing many developers missed was a native terminal inside the IDE.

Whenever you needed to run a quick Git command, execute a script, or use an AI coding assistant, you had to switch to an external terminal window. That context switching interrupted the development flow.

With the UiPath 26.0.188 February Community Release, that gap has finally been addressed. This is a meaningful shift — it positions UiPath Studio not just as an automation builder, but as a complete developer workspace.

What the Terminal Panel Means for Studio Developers

The new terminal gives developers the flexibility to work with the same command-line tools they already use in modern development environments.

Instead of switching between multiple applications, you can now:

• run scripts
• perform Git operations
• install CLI tools
• interact with AI assistants
• debug environments

— all without leaving your automation project.

In short, everything lives in one window.

A Few Ways I’ve Been Exploring the New Terminal

Here are some of the ways I’ve been experimenting with the built-in terminal during my initial exploration:

Git — Version Control Without Leaving Studio

Working with Git directly from the Studio terminal is one of the most immediate benefits.

For developers who are already comfortable with command-line Git, this workflow feels far more natural and efficient.

AI Assistance with Gemini CLI

Google’s Gemini CLI brings AI-powered code suggestions, explanations, and generation right into your terminal session. Inside UiPath Studio’s terminal, you can ask Gemini to help scaffold logic, explain a regex, or suggest an approach — without ever leaving your automation project.

Install the Gemini command-line tool:

npm install -g @google/gemini-cli

If you want to run Gemini CLI temporarily without installing it globally.

npx @google/gemini-cli

1. AI-Assisted Code Fixes Using the Terminal:

In the following example, I asked Gemini CLI to fix an issue in my UiPath Studio workflow directly from the terminal.

Gemini analyzes the project files, identifies the issue (In My case missing quotation mark) in the workflow code, and suggests or applies the required fixes. This allows developers to quickly resolve problems without manually digging through multiple files.

2. Building Workflows Using AI from the Terminal

You can also build automation workflows using AI directly from the terminal. In the example below, I used Gemini CLI inside UiPath Studio to generate a .xaml workflow.

In this simple demo, the generated workflow opens Notepad and writes “Hello World.”

While the example is basic, the same approach can be used to generate much more complex workflows. With the right prompts, AI can help quickly create and prototype automation workflows directly from the terminal.

3. Adding Workflow Annotations Using AI

We can also add annotations across an entire workflow using a single prompt in the AI-assisted terminal. In this demo, I used Gemini CLI inside UiPath Studio to automatically add annotations to the workflow.

Gemini reviews the activities in the .xaml workflow, understands the logic, and then generates meaningful annotations throughout the code. This helps quickly document the workflow and makes it easier for other developers to understand the automation.

4. Generating Documentation Using AI from the Terminal

Another useful example is generating documentation directly from the AI-assisted terminal. By giving a simple prompt to Gemini CLI inside UiPath Studio, AI can analyze the workflow files and automatically generate documentation.

It reviews the activities and workflow logic, then creates a structured document explaining how the automation works. This makes it much faster to produce technical documentation without manually going through the entire workflow.

Most of the examples above focused on using Gemini CLI, but this is just scratching the surface. There are many more possibilities when combining AI tools with the built-in terminal in UiPath Studio.

5. Using Claude CLI from the Terminal

While tools like Claude CLI can also be used from the terminal inside UiPath Studio, I haven’t explored it much yet since it is not free like Gemini CLI.

Install the Claude command-line tool:

npm install -g @anthropic-ai/claude-code

However, the example shows that the terminal can work with multiple AI CLI tools, opening up many possibilities for AI-assisted development.

6. Experimenting with UiPath LangGraph Agents

I also tried creating a LangGraph-based agent using the terminal inside UiPath Studio.

Using the terminal, I ran the command to scaffold a new agent project with the UiPath LangGraph tools. This generated files like:

• main.py
• langgraph.json
• pyproject.toml

While the agent project is created successfully, the .py files are currently not visible or editable inside UiPath Studio. To modify the Python logic, the files need to be opened in an external editor such as Visual Studio Code.

Hopefully in the future, coded agents using UiPath LangGraph, LangChain can be built entirely within UiPath Studio without needing external tools like Visual Studio Code.

A Little Bit of Fun 😄

Apart from development use cases, I also played around with the fun side of the terminal. You can actually run simple terminal games like Tetris or Snake directly inside the terminal.

It’s a small but fun reminder that the built-in terminal in UiPath Studio isn’t just for development tasks — you can also use it to experiment and explore just like any other developer terminal.

This uses Node.js and npm to launch the classic Snake directly inside the terminal.

npx tetris-cli

For Snake:

npx snake-cli

The built-in terminal in UiPath Studio adds a lot of flexibility for developers. From running Git commands to experimenting with AI tools like Gemini CLI, it opens up new ways to build and manage automations.

There’s still a lot to explore, and it will be interesting to see how this evolves in future updates. And of course, if you need a quick break, you can always run a game of Tetris or Snake right inside the terminal. 😉🎮

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Best of luck and happy automating! 🤖💫

Harness the power of UiPath’s OpenAI Agents SDK, Model Context Protocol (MCP), and Firecrawl to create a production-ready web research agent — deployable directly to UiPath Automation Cloud

If you’ve been following along with my previous articles on building coded agents in UiPath, you already know how powerful it is to combine UiPath’s orchestration capabilities with modern AI frameworks. In this article, we’re taking it up a notch — we’re going to build a web research agent using the UiPath OpenAI Agents SDK, Firecrawl’s MCP server, and UiPath’s CLI toolchain.

This agent can:

• 🔍 Search the web for any topic using Firecrawl
• 📄 Scrape individual pages for detailed content
• 🕸️ Crawl entire websites for comprehensive research
• 🗂️ Extract structured data from any URL using a custom schema

By the end of this article, you’ll have a fully working agent that you can run locally, package, and publish directly to UiPath Automation Cloud with just a few CLI commands.

🧰 Prerequisites

Before coding, make sure you have:

• 🐍 Python 3.10+
• 🤖 UiPath Automation Cloud / Orchestrator account
• 🧬 Basic familiarity with UiPath Open Ai Agents SDK
• A Firecrawl MCP Server URL (That I will show in the Tutorial how to get)

Step 1: Environment Setup

Let’s start by setting up our development environment. We’ll usepipfor package management. For faster package management, you can use the uv.

# Create project directory e.g. UiPathOpenAIAgent_FireCrawl i have created

Inside that we need to create virtual environment

python -m venv .venv

after virtual environment creation we need to activate the environment

.venv\Scripts\Activate.ps1

After activation your screen will look like this:

Step 2: Installing Required Packages

With the environment activated, we’re now ready to install the dependencies and start building our openai based UiPath agent. Upgrade the pip & install the uipath Openai package.

# Upgrade pip to the latest version
python -m pip install --upgrade pip
# Install the uipath package
pip install uipath-openai-agents

Step 3: Create Your Agent with the CLI

UiPath provides a convenient CLI command to create a new agent:

Run the following command:

uipath new OpenAI_FireCrawl

here i have given OpenAI_FireCrawl as the name of our OpenAI agent

This will create these files inside your folder

If you open the main.py file after creating a coded agent project, you’ll notice that UiPath provides a default sample implementation to help developers understand how agents work.

In the sample, a basic tool called get_weather is defined using the @function_tool decorator, which exposes the function to the agent so it can call it whenever it needs external information.

For this tutorial, we won’t be using that example. You can safely delete the entire sample code from main.py and replace it with the custom implementation provided in the next section.

We’ll build our own Web Research Agent using UiPath, the OpenAI Agents SDK, and Firecrawl via MCP, tailored specifically for this use case.

import asyncio
import os
import sys
from contextlib import asynccontextmanager

from dotenv import load_dotenv
from agents import Agent, Runner, function_tool
from agents.models import _openai_shared
from uipath_openai_agents.chat import UiPathChatOpenAI
from uipath_openai_agents.chat.supported_models import OpenAIModels
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

load_dotenv()


@asynccontextmanager
async def get_mcp_session():
    MCP_SERVER_URL = os.getenv("MCP_SERVER_URL")
    UIPATH_PAT = os.getenv("UIPATH_PAT")

    if not MCP_SERVER_URL:
        raise ValueError("MCP_SERVER_URL must be set")
    if not UIPATH_PAT:
        raise ValueError("UIPATH_PAT must be set")

    headers = {"Authorization": f"Bearer {UIPATH_PAT}"}

    async with streamablehttp_client(
        url=MCP_SERVER_URL,
        headers=headers,
        timeout=60,
    ) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            yield session


@function_tool
async def firecrawl_search(query: str, limit: int = 5) -> str:
    """Search the web using Firecrawl."""
    async with get_mcp_session() as session:
        result = await session.call_tool(
            "firecrawl_search",
            {"query": query, "limit": limit},
        )
        return str(result)


@function_tool
async def firecrawl_scrape(url: str) -> str:
    """Scrape a single webpage."""
    async with get_mcp_session() as session:
        result = await session.call_tool(
            "firecrawl_scrape",
            {"url": url},
        )
        return str(result)


@function_tool
async def firecrawl_crawl(url: str, limit: int = 10) -> str:
    """Crawl an entire website."""
    async with get_mcp_session() as session:
        result = await session.call_tool(
            "firecrawl_crawl",
            {"url": url, "limit": limit},
        )
        return str(result)


@function_tool
async def firecrawl_extract(url: str, extract_schema: str) -> str:
    """Extract structured data using a schema (pass schema as JSON string)."""
    import json
    async with get_mcp_session() as session:
        schema = json.loads(extract_schema)
        result = await session.call_tool(
            "firecrawl_extract",
            {"url": url, "schema": schema},
        )
        return str(result)


MODEL = OpenAIModels.gpt_5_1_2025_11_13

uipath_openai_client = UiPathChatOpenAI(model_name=MODEL)
_openai_shared.set_default_openai_client(uipath_openai_client.async_client)

firecrawl_agent = Agent(
    name="firecrawl_agent",
    instructions="""
You are an advanced web research assistant powered by Firecrawl.

Use the available tools appropriately:
- firecrawl_search: Search the web for information
- firecrawl_scrape: Extract content from a single URL
- firecrawl_crawl: Crawl an entire website
- firecrawl_extract: Extract structured data using a schema

Always use tools to gather information instead of guessing.
Summarize results clearly and concisely.
""",
    model=MODEL,
    tools=[
        firecrawl_search,
        firecrawl_scrape,
        firecrawl_crawl,
        firecrawl_extract,
    ],
)


def agent() -> Agent:
    """UiPath entry point — returns the agent instance."""
    return firecrawl_agent


async def main():
    """Local test entry point."""
    # Read query from CLI arg or use default
    query = sys.argv[1] if len(sys.argv) > 1 else "Search for the latest information about AI and summarize the findings."
    result = await Runner.run(firecrawl_agent, query)
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

Step 4: Copy the code from above and paste it into main.py.

This implementation builds a Web Research Agent using UiPath and the OpenAI Agents SDK.

The agent uses Firecrawl tools via MCP (Model Context Protocol) to perform web research tasks such as:

• Searching the web
• Scraping webpage content
• Crawling entire websites
• Extracting structured data

The project contains the following key files:

📄 main.py → This file holds your agent logic, tool definitions, and the UiPath entry point.

⚙️ openai_agents.json → Defines your OpenAI Agents configuration, mapping agent names to their entry points (for example: "agents": { "agent": "main.py:agent" })

🧾 pyproject.toml → Contains the project metadata such as the project name, version, author details, and required dependencies.

🪄 Step 5: Authenticate with UiPath

Before running your OpenAI agent, you need to authenticate with UiPath.
The easiest way is through the CLI authentication command:

Uipath Auth

⚙️ What happens when you run this:

1. 🌐 Browser Opens — Your default browser launches the UiPath Cloud Platform.
2. 🔑 Login — Sign in with your UiPath credentials.
3. ✅ Grant Access — Authorize the CLI to access your UiPath account.
4. ⚡ Auto-Configuration — The CLI automatically generates or updates your .env file with:

• UIPATH_URL → Your organization and tenant URL
• UIPATH_ACCESS_TOKEN → Secure access token
• UIPATH_TENANT_ID
• UIPATH_ORGANIZATION_ID

📁 Once complete, your .env file is ready — containing all the required credentials for your LlamaIndex agent to connect with UiPath seamlessly.

Your folder structure will look like this, .env file is created with details

Step 6: Generate the FireCrwal MCP Server

First, generate your Firecrawl API key:

1. Go to firecrawl.dev and create a free account
2. Navigate to firecrawl.dev/app/api-keys and generate a new API key — it will look like fc-xxxxxxxxxxxxxxxx

Firecrawl provides a ready-to-use hosted MCP server URL — no setup or self-hosting required. Simply plug your API key directly into the URL:

https://mcp.firecrawl.dev/{FIRECRAWL_API_KEY}/v2/mcp

Add Firecrawl as a Remote MCP Server in UiPath

💡 Optional: Registering Firecrawl as a Remote MCP Server in UiPath is optional. Since the Firecrawl MCP URL already includes your API key (https://mcp.firecrawl.dev/YOUR_API_KEY/v2/mcp), you can use it directly in your .env file without proxying through UiPath.

Once you have your Firecrawl API key, you need to register it as a Remote MCP Server in UiPath Automation Cloud so your agent can access it.

1. Go to My Workspace → MCP Servers → Add MCP Server
2. Select the Remote tab — this option proxies requests to an external MCP server
3. Fill in the following fields:

Replace {FIRECRAWL_API_KEY} in the Remote URL with your actual API key before clicking Add.

Once added successfully, your Firecrawl MCP server will appear in the MCP Servers list with a green Active status. Click on it to expand the details panel on the right — you’ll see all the tools that are now available to your agent:

These are exactly the tools our agent code calls via MCP — firecrawl_search, firecrawl_scrape, firecrawl_crawl, and firecrawl_extract are all confirmed available here.

Now copy the Preview URL from the MCP Server details panel and paste it as your MCP_SERVER_URL in the .env file:

Step 7: Generate PAT Token From UiPath

We also need a UiPath Personal Access Token (PAT) to authenticate MCP requests. To generate one

Create a Personal Access Token from:

Automation Cloud → User Menu → Preferences → Personal Access Tokens

Then add it to your .env file: UIPATH_PAT=your_personal_access_token_here

Your .env file will look like this

⚙️ Step 8: Initialize the UiPath Project

Set up your UiPath configuration files by running:

uipath init

One of the most useful things this command generates is the agent.mermaid file — a visual graph of your agent’s flow.

These are project configuration files that UiPath generates to manage your agent’s metadata, input/output bindings, and entry point registration

Once created, your project is fully initialized and ready to connect with UiPath!

🧩 Step 8: Test Your Agent Locally

To quickly verify our agent works correctly or not run this query

uipath run agent '{\"messages\": \"Search the web for MCP servers\"}'

You will see something like this

What's happening under the hood:

1. Agent starts → loads firecrawl_agent with all 4 tools registered
2. Calls UiPath AI Gateway → routes the request to gpt-5.1-2025-11-13
3. Model decides to call firecrawl_search → fires a request to the Firecrawl MCP server via the UiPath proxy URL
4. MCP returns results → the model synthesizes them into a clean summary
5. ✓ Successful execution

Step 9: Update pyproject.toml file

Before publishing the project to UiPath Orchestrator, we need to update the dependencies in the pyproject.toml file to ensure all required packages are included.

This step is essential to make sure the coded agent runs correctly once deployed in the UiPath environment. You can either add the missing dependencies manually or replace the entire file, updating only the project name, author name, and email with your own details.

[project]
name = "OpenAI_FireCrawl"
version = "0.0.1"
description = "OpenAI_FireCrawl"
authors = [{ name = "Your Name Here", email = "Your Email Address" }]
dependencies = [
    "uipath-openai-agents>=0.0.1, <0.1.0",
    "mcp>=1.0.0",
    "python-dotenv>=1.0.0",
]
requires-python = ">=3.11"

Step 10: Package and Publish Your Agent

After testing locally and finalizing your project, it’s time to package and publish your OpenAI agent to UiPath Automation Cloud.

Run the following command:

UiPath Pack

Once your agent is packaged, publish it directly to your UiPath tenant using:

Run the following command:

Uipath Publish

• select the target feed where the package should be published

After publishing, your OpenAI agent is live and ready to run from UiPath Orchestrator! 💼

⚙️ Step 11: Add the Published Agent as a Process in Orchestrator & Run It in UiPath Cloud

Now that your agent is published to UiPath Cloud, the next step is to create a Process in UiPath Orchestrator so it becomes executable.

Once the process is set up, you can run your OpenAI agent directly from Orchestrator!

When triggering the process:

Once published, go to Jobs → Start Job and configure the following:

Environment Configuration — add your environment varibles

UIPATH_PAT=your_pat_token_here
MCP_SERVER_URL=your_mcp_url_here

Once your agent runs successfully in UiPath Orchestrator, you’ll see the generated result in the Job Output or Logs section.

You can see the agent has successfully picked Firecrawl_Scrape tool.

Whola! 🎊 You’ve officially built, configured, and deployed your first OpenAI-powered agent in UiPath!

Now you know how to combine AI intelligence with UiPath automation to create something powerful and scalable.

Keep exploring, keep building, and who knows — your next agent might just change how automation works! ⚙️🤖

📘 Reference:

You can copy the whole Agent from my GitHub page:

GitHub - AJYoutube007/UiPathOpenAI_Agents_FireCrawl: Harness the power of UiPath's OpenAI Agents SDK, Model Context Protocol (MCP), and Firecrawl to create a production-ready web research agent - deployable directly to UiPath Automation Cloud

Explore the official UiPath LlamaIndex SDK and examples here:

👉https://uipath.github.io/uipath-python/openai-agents/quick_start/

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Best of luck and happy automating! 🤖💫

What is MCP (Model Context Protocol)?

MCP (Model Context Protocol) is a standard that allows AI agents to discover and call external tools in a structured and secure way.

Instead of hard-coding APIs into workflows, MCP lets you:

• Expose functionality as tools
• Let agents decide when and how to use them
• Execute logic outside the agent, but under its control

In UiPath, an MCP Server acts as a tool provider that agents can call during execution.

What We Are Building

In this tutorial, we will:

1. Install Gemini CLI
2. Create a UiPath MCP Server
3. Connect it to Gemini
4. Run UiPath robots using natural language

🧰 Prerequisites

Before building the MCP server, make sure you have:

• Node.js 18+ installed (for Gemini CLI)
• Gemini CLI installed and logged in
• Python 3.10+ installed
• UiPath Automation Cloud account
• UiPath Personal Access Token (PAT)

Step 1: Environment Setup & Installing Required Packages

1. Node.js (for Gemini CLI)

• Install Node.js version 18 or higher
• Download from:
  https://nodejs.org
• Verify installation:

2. Install Gemini CLI

Install the Gemini command-line tool:

npm install -g @google/gemini-cli

If you want to run Gemini CLI temporarily without installing it globally.

npx @google/gemini-cli

Running npx @google/gemini-cli starts Gemini CLI without installing it globally. Once the CLI starts, you will see the Gemini welcome screen.

3. Install Gemini CLI

Environment Setup

Let’s start by setting up our development environment. We’ll usepipfor package management. For faster package management, you can use the uv.

# Create project directory e.g. Gemini_MCP i have created

Inside that we need to create virtual environment

python -m venv .venv

after virtual environment creation we need to activate the environment

.venv\Scripts\Activate.ps1

With the virtual environment activated, we’re now ready to install the required dependencies and start building our MCP Server.

pip install fastmcp requests

4. UiPath Personal Access Token (PAT)

Create a Personal Access Token from:

Automation Cloud → User Menu → Preferences → Personal Access Tokens

Step 2: Create the MCP Server

Open your project folder. In my case, it is Gemini_MCP.

Create a new Python file inside it.
You can name it uipath_server.py or any name you prefer.

Your folder will look something like this:

Copy the code from below and paste it into uipath_server.py, then save the file.

Replace these values with your actual UiPath details in Python Script Below

ORG_NAME = "Your Org Name"
TENANT_NAME = "Your Tenant Name"

import os
import requests
from fastmcp import FastMCP
from typing import Optional, List, Dict

# =========================
# MCP Server Initialization
# =========================
mcp = FastMCP("UiPath Manager")

# =========================
# UiPath Configuration
# =========================
ORG_NAME = "Your Org Name"
TENANT_NAME = "Your Tenent Name"
BASE_URL = f"https://cloud.uipath.com/{ORG_NAME}/{TENANT_NAME}/orchestrator_/odata"


# =========================
# Helper: Auth Header
# =========================
def _get_headers(folder_id: Optional[int] = None) -> Dict[str, str]:
    token = os.getenv("UIPATH_PAT")
    if not token:
        raise ValueError("UIPATH_PAT environment variable is not set")

    headers = {
        "accept": "application/json",
        "Content-Type": "application/json",
        "authorization": f"Bearer {token}"
    }

    if folder_id is not None:
        headers["X-UIPATH-OrganizationUnitId"] = str(folder_id)

    return headers


# =========================
# MCP Tool: List Processes
# =========================
@mcp.tool()
def list_processes() -> List[Dict]:
    """
    Lists all available processes with folder information.
    """
    try:
        headers = _get_headers()

        response = requests.get(
            f"{BASE_URL}/Releases",
            headers=headers,
            timeout=15
        )

        response.raise_for_status()
        releases = response.json().get("value", [])

        return [
            {
                "Name": r.get("Name"),
                "ReleaseKey": r.get("Key"),
                "OrganizationUnitId": r.get("OrganizationUnitId")
            }
            for r in releases
        ]

    except Exception as e:
        return [{"error": str(e), "type": type(e).__name__}]


# =========================
# MCP Tool: Run Process
# =========================
@mcp.tool()
def run_process(name: str, arguments: Optional[Dict] = None) -> Dict:
    """
    Starts a UiPath process by name.
    """
    try:
        # Step 1: Find process
        headers = _get_headers()

        params = {
            "$filter": f"Name eq '{name}'"
        }

        response = requests.get(
            f"{BASE_URL}/Releases",
            headers=headers,
            params=params,
            timeout=15
        )

        response.raise_for_status()
        releases = response.json().get("value", [])

        if not releases:
            return {"error": f"Process '{name}' not found"}

        release = releases[0]
        release_key = release.get("Key")
        folder_id = release.get("OrganizationUnitId")

        if folder_id is None:
            return {"error": "FolderId not found for this process"}

        # Step 2: Prepare input arguments
        input_args = "{}"
        if arguments:
            input_args = str(arguments).replace("'", '"')

        body = {
            "startInfo": {
                "ReleaseKey": release_key,
                "Strategy": "ModernJobsCount",
                "JobsCount": 1,
                "InputArguments": input_args
            }
        }

        # Step 3: Start job
        start_headers = _get_headers(folder_id)

        start_response = requests.post(
            f"{BASE_URL}/Jobs/UiPath.Server.Configuration.OData.StartJobs",
            headers=start_headers,
            json=body,
            timeout=15
        )

        start_response.raise_for_status()
        result = start_response.json()
        jobs = result.get("value", [])

        job_ids = [job.get("Id") for job in jobs]

        return {
            "message": f"Process '{name}' started successfully",
            "FolderId": folder_id,
            "JobIds": job_ids
        }

    except requests.exceptions.HTTPError as e:
        return {
            "error": str(e),
            "response": e.response.text
        }
    except Exception as e:
        return {"error": str(e), "type": type(e).__name__}


# =========================
# MCP Tool: Check Job Status
# =========================
@mcp.tool()
def check_job_status(job_id: int, folder_id: int) -> Dict:
    """
    Checks the status of a UiPath job.
    """
    try:
        headers = _get_headers(folder_id)

        response = requests.get(
            f"{BASE_URL}/Jobs({job_id})",
            headers=headers,
            timeout=15
        )

        response.raise_for_status()
        job = response.json()

        return {
            "JobId": job.get("Id"),
            "State": job.get("State"),
            "StartTime": job.get("StartTime"),
            "EndTime": job.get("EndTime"),
            "ReleaseName": job.get("ReleaseName")
        }

    except Exception as e:
        return {"error": str(e), "type": type(e).__name__}


# =========================
# MCP Entry Point
# =========================
if __name__ == "__main__":
    mcp.run()

This Python script creates a UiPath MCP server that connects an AI agent to UiPath Orchestrator. It exposes the following tools:

• list_processes – retrieves all available processes from Orchestrator
• run_process – starts a process by its name
• check_job_status – checks the status of a running job

When you give a natural language command in an AI agent like Gemini CLI, the agent selects the appropriate tool, calls the MCP server, and the server executes the request through the UiPath Orchestrator API.

Step 3: Connect MCP Server to Gemini

Now our script is ready. Next, we need to add the MCP server to the Gemini settings file so the agent can use it.

Open the Gemini configuration folder:

C:\Users\<your-username>\.gemini\settings.json

Inside this folder open settings.json file

{
  "hasSeenIdeIntegrationNudge": true,
  "security": {
    "auth": {
      "selectedType": "oauth-personal"
    }
  },
  "mcpServers": {
    "uipath": {
      "command": "python",
      "args": [
        "C:\\Gemini_MCP\\uipath_server.py"
      ],
      "env": {
        "UIPATH_PAT": "Your Personal Access Token here"
      }
    }
  }
}

In the settings.json you need to replace the args section with:

• the full path to your Python MCP server file
• the access token as the argument

Step 4: Test with Natural Language Inside Gemini CLI

Go to your terminal

You already have the Gemini CLI installed. Type

gemini

Inside the Gemini CLI, check the connected MCP tools:

/mcp list

You will see

Now the tool is available, you can ask in natural language to check what processes are available.

You will see all the processes which are available

Now you can simply run any process you want using a natural language prompt. i will run the Extract.Bank.Statements

after the run successfully started you will see Job ID

You can check the status of the process

You can see the status, In my case it got suspended as this is action center process

I hope you enjoyed building this as much as I did.

This simple setup shows how you can connect UiPath with an MCP server and control your automations directly from the Gemini CLI using natural language. With just a few configuration steps, you can start processes, check their status, and interact with your robots without writing complex scripts. This approach opens the door to more agentic and conversational automation experiences using UiPath.

📘 Reference:

• Get started with Gemini CLI
• Orchestrator - Introduction

You can get the full code here-

GitHub - AJYoutube007/uipath-mcp-gemini-cli

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Best of luck and happy automating! 🤖💫

What is MCP (Model Context Protocol)?

MCP (Model Context Protocol) is a standard that allows AI agents to discover and call external tools in a structured, secure, and runtime-managed way.

Instead of hard-coding APIs into workflows, MCP lets you:

• Expose functionality as tools
• Let agents decide when and how to use them
• Execute logic outside the agent, but under its control

In UiPath, an MCP Server acts as a tool provider for agents.

What We Are Building in This Tutorial

In this tutorial, we are building a UiPath Coded MCP Server that acts as a Meme Generator service powered by the Imgflip API.

This MCP Server exposes meme-related capabilities as agent-callable tools, allowing UiPath Agents to:

• Discover popular meme templates
• Select an appropriate template
• Generate a captioned meme dynamically

All of this happens through agent reasoning, not hard-coded workflows.

🧰 Prerequisites

Before building the MCP server, make sure you have:

🐍 Python 3.10 or higher

🤖 UiPath Automation Cloud / Orchestrator account

🔗 Basic understanding of UiPath Agents and MCP (Model Context Protocol)

Step 1: Environment Setup & Installing Required Packages

Let’s start by setting up our development environment. We’ll usepipfor package management. For faster package management, you can use the uv.

# Create project directory e.g. Meme_MCP_2 i have created

Inside that we need to create virtual environment

python -m venv .venv

after virtual environment creation we need to activate the environment

.venv\Scripts\Activate.ps1

With the virtual environment activated, we’re now ready to install the required dependencies and start building our Coded MCP Server.

First, upgrade pip to the latest version and install the UiPath MCP package, which provides the tools needed to create and run an MCP server

# Upgrade pip
python -m pip install --upgrade pip
# Install packages
pip install uipath-mcp
pip install requests

Step 2: Create Your Agent with the CLI

UiPath provides a convenient CLI command to create a new MCP Server:

Run the following command:

uipath new meme-server007 

UiPath scaffolds a new Coded MCP Server project and generates the following files:

1. server.pyA sample MCP math server using FastMCP

2. mcp.jsonConfiguration file needed for coded UiPath MCP Servers.

3. pyproject.tomlProject metadata and dependencies as per PEP 518.

If you open the server.py file, you’ll notice that UiPath provides a sample MCP server implementation by default. This sample uses FastMCP to perform basic math operations.

For this tutorial, we won’t be using that example. You can safely delete the entire sample code from server.py and replace it with the custom implementation provided in the next section.

We’ll be building our own Meme Generator MCP Server, which allows you to fetch meme templates from Imgflip and generate custom memes with captions directly via our MCP server.

import os
import requests
from mcp.server.fastmcp import FastMCP

# Read Imgflip credentials from environment variables
IMGFLIP_USERNAME = os.getenv("IMGFLIP_USERNAME")
IMGFLIP_PASSWORD = os.getenv("IMGFLIP_PASSWORD")

mcp = FastMCP(
    name="meme-server"
)

# -------------------------
# TOOL 1: Get memes
# -------------------------
@mcp.tool()
def get_memes(limit: int = 10) -> dict:
    """
    Get trending meme templates from Imgflip
    """

    url = "https://api.imgflip.com/get_memes"
    response = requests.get(url, timeout=30)
    data = response.json()

    if not data.get("success"):
        return {
            "success": False,
            "error_message": "Failed to fetch memes"
        }

    memes = data["data"]["memes"][:limit]

    return {
        "success": True,
        "count": len(memes),
        "memes": memes
    }


# -------------------------
# TOOL 2: Caption image
# -------------------------
@mcp.tool()
def caption_image(
    template_id: str,
    text0: str = "",
    text1: str = ""
) -> dict:
    """
    Create a meme using Imgflip caption_image API
    """

    if not IMGFLIP_USERNAME or not IMGFLIP_PASSWORD:
        return {
            "success": False,
            "error_message": "IMGFLIP_USERNAME or IMGFLIP_PASSWORD not set"
        }

    url = "https://api.imgflip.com/caption_image"

    payload = {
        "template_id": template_id,
        "username": IMGFLIP_USERNAME,
        "password": IMGFLIP_PASSWORD,
        "text0": text0,
        "text1": text1
    }

    response = requests.post(url, data=payload, timeout=30)
    data = response.json()

    if not data.get("success"):
        return {
            "success": False,
            "error_message": data.get("error_message", "Unknown error")
        }

    return {
        "success": True,
        "url": data["data"]["url"],
        "page_url": data["data"]["page_url"]
    }


if __name__ == "__main__":
    mcp.run()

Step 3: Copy the code above and paste it into server.py

This server exposes two tools:

• get_memes → fetch meme templates
• caption_image → generate a captioned meme

This is a fun example, but the same architecture applies to real enterprise APIs.

Step 4: Initialize the UiPath Project

Set up your UiPath configuration files by running:

uipath init

creates the core files needed for a UiPath Coded MCP Server.

It generated following files

.envLocal environment variables & secrets. Not packaged or published.

uipath.jsonDefines tool bindings and input/output schemas used by UiPath Agents.

Step 5: Get imgflip API Credentials

Go to https://imgflip.com/api, create an account, and note down your username and password. These credentials are required to call the Imgflip API for meme generation.

Step 6: Authenticate with UiPath

Before running your MCP Server locally, you need to authenticate with UiPath.
The easiest way is through the CLI authentication command:

Uipath Auth 

⚙️ What happens when you run this:

1. 🌐 Browser Opens — Your default browser launches the UiPath Cloud Platform.
2. 🔑 Login — Sign in with your UiPath credentials.
3. ✅ Grant Access — Authorize the CLI to access your UiPath account.
4. ⚡ Auto-Configuration — The CLI automatically generates or updates your .env file with:

• UIPATH_URL → Your organization and tenant URL
• UIPATH_ACCESS_TOKEN → Secure access token
• UIPATH_TENANT_ID
• UIPATH_ORGANIZATION_ID

Step 7: Update .env file

Add the Imgflip API credentials to the .env file only when running the MCP server locally.

📍 For Local / On-Prem Execution:

When running locally:

• JSON-RPC requests are securely tunneled from UiPath servers to your local MCP server
• On startup, the local server automatically registers itself with UiPath
• MCP servers are folder-scoped in Orchestrator

Because of this, you must define the UiPath folder context explicitly.

Since MCP servers are folder-scoped in Orchestrator, you need to set the UIPATH_FOLDER_PATH environment variable. To do this:

1. Copy the folder path from your Orchestrator interface & Add it to the .env file

IMGFLIP_USERNAME=your_username
IMGFLIP_PASSWORD=your_password
UIPATH_FOLDER_PATH=Shared/MyFolder

Your .env file will look like this

Update pyproject.toml file

Before publishing the project to UiPath Orchestrator, we need to update the dependencies in the pyproject.toml file to ensure all required packages are included.

[project]
name = "meme-server007"
version = "0.0.1"
description = "Description for meme-server007 project"
authors = [{ name = "Your Name", email = "Your Email Address" }]
dependencies = [
    "uipath-mcp>=0.0.106",
    "requests>=2.31.0",
    "python-dotenv>=1.0.0"
]
requires-python = ">=3.11"

Step 8: To Run the server locally

uipath run meme-server007

If the process runs successfully, and you’ve provided the folder path of My Workspace, you can navigate to My Workspace → MCP Servers to see the hosted server. The server type will be displayed as Self-Hosted.

Verify MCP Server in Orchestrator

If the server starts successfully with My Workspace as the folder path:

1. Go to Orchestrator → My Workspace → MCP Servers
2. You’ll see the server listed (e.g., meme-server)

✔ What You’ll See

• Type: Self Hosted
• Status: Active
• View tools shows all exposed MCP tools

This confirms the MCP server is registered and ready for agent use.

Step 9: Package and Publish Your MCP Server

After completing local testing and finalizing your UiPath Coded MCP Server, package it for deployment to UiPath Automation Cloud.

uipath pack

After packaging the MCP server, publish it to My Workspace using:

uipath publish --my-workspace

Click the Process Configuration link shown in the terminal

You’ll be redirected to Orchestrator → Process configuration

In Environment Configuration, add the required values:

• IMGFLIP_USERNAME
• IMGFLIP_PASSWORD

Save the configuration

You can see in the processes

Step 10: Add the MCP Server in Orchestrator

1. Go to Orchestrator → My Workspace → MCP Servers
2. Click Add MCP Server

Select Coded

1. Enter the MCP Server name
2. Select the published Process (MCP Server)
3. Click Add

After adding the server, you can check the server & tools

✅ MCP Server Ready for Use

As you can see:

• The MCP server is Active
• All exposed tools (get_memes, caption_image) are listed and available

This means the MCP server can now be used in:

• Coded Agents
• UiPath Agents
• Agentic workflows

Next, let’s see how an agent actually uses this MCP server in action.

Step 11: Go to UiPath Cloud Studio & Select Agent

We need to attach our MCP server as a tool to our agent. Click on the Tool Select MCP Server

Select your MCP Name in my case it is meme_server007 & i can see 2 tools inside it get_memes & Caption_image

now click on the agent & update this system prompt:

You are a meme assistant.


Rules you must strictly follow:
1. If the user asks to create or caption a meme, you MUST first call the `get_memes` tool.
2. From the returned templates, choose the most appropriate meme template based on the meaning of the user request.
3. After selecting a template, call the `caption_image` tool with:
   - template_id
   - text0 (top text)
   - text1 (bottom text)
4. Do NOT ask the user for a template ID.
5. Do NOT expose tool calls, credentials, or internal reasoning.
6. Return only the final meme image URL to the user.

& User Prompt: You can cutomize as per your requirment

Create a meme about MCP finally working after many redeployments

it will look like this

What the Agent Does

1. Reads the user prompt
2. Calls the get_memes tool to fetch meme templates
3. Selects the most relevant template automatically
4. Calls the caption_image tool with:

• template_id
• text0 (top text)
• text1 (bottom text)

5. Returns only the final meme image URL

You can see the output

when you click on the output link you can see the meme

This was a simple agent built purely for demo purposes, but the possibilities don’t stop here. You can easily extend this further to send the generated meme via email, share it directly on WhatsApp, or plug it into any downstream automation.

The goal of this demo was to show how UiPath MCP Servers and Agents work together — from exposing tools, to agent orchestration, to delivering real outcomes with minimal setup.

I hope you enjoyed building this as much as I did.
Happy automating 🚀

📘 Reference:

Getting Started - UiPath SDK

You can get the full code here-

https://github.com/AJYoutube007/MCP_Meme_Generator

🎥 YouTube tutorial of this:-

https://youtu.be/GzE5WGVkl0s?si=-WpvNtl-auiAKhQL

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Best of luck and happy automating! 🤖💫

UiPath Integration Service makes it easy to consume external APIs without writing custom HTTP logic in every automation. Using Connector Builder, you can visually define authentication, operations, inputs, and outputs — and expose them as reusable activities across UiPath Studio and Automation Cloud.

In this article, we’ll build a custom connector for the NewsAPI /v2/top-headlines endpoint using UiPath Connector Builder, following the same design principles as the official UiPath documentation—but tailored specifically for NewsAPI.

🧾 Prerequisites

Before starting, ensure you have:

✔ UiPath Automation Cloud access
✔ Integration Service enabled
✔ Permission to use Connector Builder
✔ A NewsAPI API Key from https://newsapi.org
✔ Basic understanding of REST APIs and JSON

Step 1: Create a New Connector

1. Go to Automation Cloud
2. Navigate to Integration Service → Connectors
3. Click Build a Connector

Click on the Create new connector

Before we start building the connector, head over to https://newsapi.org.
NewsAPI is a free news API platform that allows you to access articles and breaking news headlines from thousands of news sources and blogs across the web.

To use the API, you’ll need to create an account on the website and generate your API key, which will be required later while configuring authentication in UiPath Connector Builder.

When building a custom connector in UiPath, you have two options:

• Start from an API definition — Import a Postman or Swagger/OpenAPI file, either from a local file or a public URL. (From a URL — Enter a file URL, such as https://petstore.swagger.io/v2/swagger.json.)Connector Builder uses this definition to auto-generate most of the connector configuration.
• Start from blank— Manually configure authentication, operations, and schemas.

Step 2: Set Up the Connector Basics:

👉 In this tutorial, we’ll start from blank to understand the connector setup step by step.

On the Create new connector screen, select Start from blank to begin with an empty canvas.

Provide the basic connector details:

Name: NewsAPI.Org

Description: Locate articles and breaking news headlines from news sources across the web

Icon: Upload a suitable icon (for example, NewsAPI.png) to make the connector easily recognizable in Integration Service and Studio.

Once these details are filled in, proceed to configure authentication and operations for the connector.

Step 3: Configure the Base API

In the Base API tab, set the Base URL to:

https://newsapi.org

Since NewsAPI does not specify a default pagination strategy, keep the Pagination type set to None and leave the remaining values as default.
Ensure both Content-Type and Accept headers are set to application/json.

Step 4: Configure Authentication

Navigate to the Authentication tab and select API Key as the authentication type from the dropdown.
Set Ask the user to Yes for the API key so users are prompted to provide their NewsAPI key when creating a connection.

Step 5: Configure the Response Schema

After configuring authentication the next step is to perform and validate the actual API calls.

1. From the left-side panel, navigate to Activity→ Create new resource to begin defining the API operations.

After clicking Create new resource, a pop-up window appears showing the Base URL.
In the Path field, add the API endpoint for fetching top headlines. For this connector, use:

/v2/top-headlines?country={country}&apiKey={apiKey}

Provide a meaningful name such as Top Headlines and select List All Records (GET) as the method.
This defines the GET operation that will retrieve top news headlines from NewsAPI.

This API endpoint returns a response in JSON format, containing a list of top headline articles with details such as the title, description, source, URL, and published time.

Once the resource is created, your request will look like this.
You’ll see the Top Headlines endpoint along with the parameters extracted from the URL. The apiKey and country parameters are automatically detected and listed, making them available as inputs for the activity.

This makes it easy to pass different values at runtime when using the connector in UiPath Studio.

Step 6: Establish A Connection

Before you can start fetching data, you need to establish a connection. Click on the Not connected dropdown and select Add connection.

It will open another tab where we can need to add our API key from the newsapi.org

Once the connection is successfully established, you can invoke the API by clicking the Send Request button.

Step 7: Test API calls

Before sending the request, make sure to provide your API key and specify the country name for which you want to fetch the top news. Once these details are added, triggering the request will return the latest headlines for the selected country.

After executing the request, the API response is displayed in the Response panel. This section shows the complete output returned by the service, allowing you to verify the status, inspect the response body, and analyze the data retrieved from the API.

🎉 Voilà! You’ve successfully built your connector.

Step 8: Publish You Connector

The final step is to publish it. Click Publish to make the connector available in your tenant. Once published, the connector will appear in the list of connectors featured in your tenant and can be used across your automations.

After clicking Publish, a Publish Connector window appears.

In this window, provide the Documentation URL (for example, the official API documentation link) and add a brief description explaining the purpose of the connector. You can also choose to include the HTTP Request activity and enable the Data Mapper, based on your integration needs.

Once all the details are filled in, click Publish to complete the process. The publishing may take a few minutes, after which the connector becomes available in your tenant. I have added the documentation for the newsapi.org (https://newsapi.org/docs)

Once the publishing process is complete, the NewsAPI.org connector becomes active. You can now see it listed under Connectors in your tenant.

With the connector successfully published, you can now use it in UiPath Studio Web as well as UiPath Studio (Desktop).

Step 9: Use the Connector in UiPath Studio

The NewsAPI.org connector appears in the Activities panel, where you can directly drag and drop activities such as List All Records or HTTP Request into your workflow. By providing the required inputs like the API key and country, you can fetch top headlines and seamlessly work with the response data — log article titles, iterate through results, or integrate them into downstream automation logic.

here Output panel displays the result of iterating through all the articles returned by the API.

Using a For Each activity, the workflow loops through the list of articles and logs each article’s title individually.

✅ Final Thoughts

Using UiPath Connector Builder, you can convert a simple REST API into a fully reusable, enterprise-ready connector. The NewsAPI Top Headlines connector is a great example of how external data can be brought into automations without cluttering workflows with raw HTTP logic, and instead exposed as clean, reusable activities that work seamlessly in Studio Web and Studio Desktop.

Once published, the connector becomes a shared asset across teams and projects — making automations cleaner, smarter, and much easier to maintain.

Keep exploring, keep building, and who knows — your next connector might just change how automation works! ⚙️🤖

📘 Reference:

• NewsAPI Documentation: https://newsapi.org/docs
• UiPath Connector Builder Documentation: https://docs.uipath.com/integration-service/docs/connector-builder-overview

In an era of information overload, quickly extracting key insights from web pages has become critical for modern business automation. Teams constantly sift through documentation, knowledge bases, and external websites — spending valuable time reading instead of acting.

But what if your UiPath automations could read any webpage and deliver a concise summary in seconds?

In this tutorial, we’ll build exactly that — a Webpage Summarizer Coded Agent powered by LlamaIndex workflows and Google Gemini, fully integrated into UiPath’s Coded Automation framework.

This guide is beginner-friendly. Even if you’re new to UiPath Coded Agents, Python-based automations, or LlamaIndex, you’ll be able to follow along step by step and understand not just how it works, but why each component is used.

🧰 Prerequisites

Before coding, make sure you have:

• 🐍 Python 3.10+
• 🤖 UiPath Automation Cloud / Orchestrator account
• 🧬 Basic familiarity with LlamaIndex & Google Gemini

Step 1: Environment Setup

Let’s start by setting up our development environment. We’ll usepipfor package management. For faster package management, you can use the uv.

# Create project directory e.g. Llamaindex_WebPageSummarization i have created

Inside that we need to create virtual environment

python -m venv .venv

after virtual environment creation we need to activate the environment

.venv\Scripts\Activate.ps1

After activation your screen will look like this:

Step 2: Installing Required Packages

With the environment activated, we’re now ready to install the dependencies and start building our llamaindex based UiPath agent. Upgrade the pip & install the uipath llamaindex package.

# Upgrade pip
python -m pip install --upgrade pip
# Install packages
pip install uipath-llamaindex

Step 3: Create Your Agent with the CLI

UiPath provides a convenient CLI command to create a new agent:

Run the following command:

uipath new your_agent_name

here i have given webpage_Summarizer as the name of our llamaindex agent

This will create these files inside your folder

If you open the main.py file, you’ll notice that UiPath provides a sample implementation by default. This sample uses an OpenAI API key to generate a joke on a given topic and then critiques it.

For this tutorial, we won’t be using that example. You can safely delete the entire sample code from main.py and replace it with the custom implementation provided in the next section.

We’ll be building our own Webpage Summarizer Coded Agent, tailored specifically for this use case.

# main.py
import os
from dotenv import load_dotenv

from llama_index.core.workflow import (
    Workflow,
    step,
    StartEvent,
    StopEvent,
    Event,
)
from llama_index.readers.web import SimpleWebPageReader
from google import genai

# ---------------------------
# Load env vars
# ---------------------------
load_dotenv()
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
if not GEMINI_API_KEY:
    raise EnvironmentError("GEMINI_API_KEY not found in .env")

# ---------------------------
# Events
# ---------------------------
class UrlEvent(StartEvent):
    url: str

class PageContentEvent(Event):
    url: str
    content: str

class SummaryEvent(StopEvent):
    url: str
    summary: str

# ---------------------------
# Workflow
# ---------------------------
class UrlSummarizerWorkflow(Workflow):

    @step
    async def load_page(self, ev: UrlEvent) -> PageContentEvent:
        reader = SimpleWebPageReader()
        documents = reader.load_data([ev.url])

        # Combine all document text
        content = "\n".join(doc.text for doc in documents)

        # Keep within free-tier limits
        content = content[:6000]

        return PageContentEvent(url=ev.url, content=content)

    @step
    async def summarize(self, ev: PageContentEvent) -> SummaryEvent:
        client = genai.Client(api_key=GEMINI_API_KEY)

        prompt = f"""
        Summarize the following webpage content in concise bullet points.
        Focus on key ideas and avoid repetition.

        CONTENT:
        {ev.content}
        """

        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=prompt,
        )

        return SummaryEvent(
            url=ev.url,
            summary=response.text.strip(),
        )

# ---------------------------
# Required entrypoint
# ---------------------------
workflow = UrlSummarizerWorkflow(timeout=60, verbose=True)

Step 4: Copy the code above and paste it into main.py.

This implementation uses LlamaIndex workflows to structure a simple two-step flow:

1. Fetch webpage content using LlamaIndex’s web reader
2. Summarize the content using Google Gemini

LlamaIndex manages the workflow and data flow, while Gemini performs the actual summarization — resulting in a clean, modular, and easy-to-follow coded agent.

The project contains the following key files:

📄 main.py → This file holds your agent logic.

⚙️ llama_index.json → Defines your LlamaIndex workflow configuration, mapping workflow names to their entry points
(for example: "workflows": { "agent": "main.py:agent" })

🧾 pyproject.toml → Contains the project metadata such as the project name, version, author details, and required dependencies.

Next, we need to install a few required dependencies for this project. These packages provide support for LlamaIndex workflows, Google Gemini, and environment variable management.

pip install llama-index google-genai python-dotenv

🪄 Step 5: Authenticate with UiPath

Before running your LangGraph agent, you need to authenticate with UiPath.
The easiest way is through the CLI authentication command:

Uipath Auth 

⚙️ What happens when you run this:

1. 🌐 Browser Opens — Your default browser launches the UiPath Cloud Platform.
2. 🔑 Login — Sign in with your UiPath credentials.
3. ✅ Grant Access — Authorize the CLI to access your UiPath account.
4. ⚡ Auto-Configuration — The CLI automatically generates or updates your .env file with:

• UIPATH_URL → Your organization and tenant URL
• UIPATH_ACCESS_TOKEN → Secure access token
• UIPATH_TENANT_ID
• UIPATH_ORGANIZATION_ID

📁 Once complete, your .env file is ready — containing all the required credentials for your LlamaIndex agent to connect with UiPath seamlessly.

Your folder structure will look like this, .env file is created with details

Step 6: Generate the Google Gemini API Key

To use Google Gemini, you’ll need an API key stored in your .env file.

1. Go to https://aistudio.google.com/
2. Create a sample project
3. Generate a Google Gemini API key

Google provides a free tier for basic usage, which is sufficient for this tutorial.

Once you have the key, add it to your .env file:

GEMINI_API_KEY=your_api_key_here

Your coded agent will automatically read this key at runtime.

Your .env file will look something like this all UiPath keys will be auto generated but you need to add the GEMINI_API_KEY in the file.

⚙️ Step 7: Initialize the UiPath Project

Set up your UiPath configuration files by running:

uipath init

This command generates essential project files:

• 🧾 uipath.json → Links your LlamaIndex agent to UiPath
• 🪄 agent.mermaid → (Optional) A visual workflow diagram of your agent’s process

Once created, your project is fully initialized and ready to connect with UiPath!

🧩 Step 8: Test Your Agent Locally

To quickly verify your LlamaIndex agent before deployment: we need to create an input.json file in the project folder. This file allows us to pass structured or complex inputs—such as a URL—to the coded agent in a clean and reliable way. You can give any URL in here which you want to pass to your agent.

{
  "url": "https://rickandmorty.fandom.com/wiki/Rick_and_Morty_(TV_series)"
}

Run the following command:

uipath run agent --input-file input.json

Once you run this command in the terminal, you’ll see that the agent executes successfully — confirming that your coded agent is working correctly.

Step 9: Update pyproject.toml file

Before publishing the project to UiPath Orchestrator, we need to update the dependencies in the pyproject.toml file to ensure all required packages are included.

This step is essential to make sure the coded agent runs correctly once deployed in the UiPath environment. You can either add the missing dependencies manually or replace the entire file, updating only the project name, author name, and email with your own details.

[project]
name = "webpage_Summarizer"
version = "0.0.1"
description = "webpage_Summarizer"
authors = [{ name = "Add Your Name", email = "Your Email Address" }]
dependencies = [
    "uipath-llamaindex>=0.1.0",
    "llama-index>=0.10.40",
    "llama-index-readers-web>=0.1.16",
    "google-genai>=0.6.0",
    "python-dotenv>=1.0.1",
    "requests>=2.32.0"
]
requires-python = ">=3.11"

Step 10: Package and Publish Your Agent

After testing locally and finalizing your project, it’s time to package and publish your LlamaIndex agent to UiPath Automation Cloud.

Run the following command:

uipath pack

🧩 What it does:

• 📦 Compiles your project into a deployment-ready .nupkg file
• 💾 Saves the package inside the .uipath directory

Your agent is now packaged and ready to be published to UiPath Orchestrator or Automation Cloud! 🌐

☁️ Step 11: Publish Your Agent to UiPath Cloud

Once your agent is packaged, publish it directly to your UiPath tenant using:

Run the following command:

uipath publish

⚙️ What happens:

• 🚀 Uploads the packaged .nupkg file to the UiPath Cloud Orchestrator
• 🌐 Makes your agent available for execution within your tenant’s environment
• 🎯 Prompts you to select the target feed where the package should be published

After publishing, your LlamaIndex agent is live and ready to run from UiPath Orchestrator! 💼

⚙️ Step 12: Add the Published Agent as a Process in Orchestrator & Run It in UiPath Cloud

Now that your agent is published to UiPath Cloud, the next step is to create a Process in UiPath Orchestrator so it becomes executable.

Once the process is set up, you can run your LlamaIndex agent directly from Orchestrator!

When triggering the process:

• 🧠 Provide a URL as input, for example: "https://powerpuffgirls.fandom.com/wiki/Powerpuff_Girls_Wiki"
• 🌐 Set your API key in the environment variables, since we are calling external APIs like Gemini

And that’s it — your agent is now ready to fetch and process data from the web through UiPath!

Once your agent runs successfully in UiPath Orchestrator, you’ll see the generated result in the Job Output or Logs section.

Whola! 🎊 You’ve officially built, configured, and deployed your first LlamaIndex-powered agent in UiPath!

Now you know how to combine AI intelligence with UiPath automation to create something powerful and scalable.

Keep exploring, keep building, and who knows — your next agent might just change how automation works! ⚙️🤖

📘 Reference:

You can copy the whole Agent from my GitHub page:

👉https://github.com/AJYoutube007/Llamaindex_WebPageSummarization

Explore the official UiPath LlamaIndex SDK and examples here:

👉https://github.com/UiPath/uipath-llamaindex-python

👉https://uipath.github.io/uipath-python/llamaindex/quick_start/

In case of any doubts or if you just want to have a fun conversation, feel free to reach out anytime: Abhishek Jagtap on LinkedIn

Best of luck and happy automating! 🤖💫