Building Event-Driven AI Agents with UAgents and Google Gemini: A Modular Python Implementation Guide

Target Audience Analysis

The target audience for this guide includes developers, data scientists, and business managers interested in implementing AI solutions. They are likely to have experience with Python programming and an understanding of AI concepts. Their pain points include:

• Difficulty in integrating AI models into existing workflows.
• Challenges in managing the lifecycle of AI agents.
• Need for efficient communication between different AI components.

Their goals are to:

• Build scalable AI applications.
• Utilize event-driven architectures for better performance.
• Leverage the capabilities of Google Gemini for AI functionalities.

Interests include modular programming, event-driven systems, and advancements in AI technologies. They prefer clear, concise communication that is rich in technical detail and practical applications.

Tutorial Overview

This tutorial demonstrates how to use the UAgents framework to build a lightweight, event-driven AI agent architecture on top of Google’s Gemini API. We will cover the following steps:

• Applying nest_asyncio to enable nested event loops.
• Configuring your Gemini API key and instantiating the GenAI client.
• Defining communication contracts and Pydantic models.
• Creating two UAgents: a “gemini_agent” for processing questions and a “client_agent” for sending queries.
• Running the agents concurrently using Python’s multiprocessing utility.

Installation

To get started, install the necessary libraries:

!pip install -q uagents google-genai

Setting Up the Environment

Import essential modules and set up your environment:

import os, time, multiprocessing, asyncio
import nest_asyncio  
from google import genai
from pydantic import BaseModel, Field
from uagents import Agent, Context

nest_asyncio.apply()

API Key Configuration

Set your Google Gemini API key in the environment:

os.environ["GOOGLE_API_KEY"] = "Use Your Own API Key Here"
client = genai.Client()

Defining Message Models

Use Pydantic to define structured message formats:

class Question(BaseModel):
    question: str = Field(...)

class Answer(BaseModel):
    answer: str = Field(...)

Creating the Gemini Agent

Instantiate the UAgents “gemini_agent”:

ai_agent = Agent(
    name="gemini_agent",
    seed="agent_seed_phrase",
    port=8000,
    endpoint=["http://127.0.0.1:8000/submit"]
)

@ai_agent.on_event("startup")
async def ai_startup(ctx: Context):
    ctx.logger.info(f"{ai_agent.name} listening on {ai_agent.address}")

def ask_gemini(q: str) -> str:
    resp = client.models.generate_content(
        model="gemini-2.0-flash",
        contents=f"Answer the question: {q}"
    )
    return resp.text

@ai_agent.on_message(model=Question, replies=Answer)
async def handle_question(ctx: Context, sender: str, msg: Question):
    ans = ask_gemini(msg.question)
    await ctx.send(sender, Answer(answer=ans))

Creating the Client Agent

Set up the “client_agent” to send questions:

client_agent = Agent(
    name="client_agent",
    seed="client_seed_phrase",
    port=8001,
    endpoint=["http://127.0.0.1:8001/submit"]
)

@client_agent.on_event("startup")
async def ask_on_start(ctx: Context):
    await ctx.send(ai_agent.address, Question(question="What is the capital of France?"))

@client_agent.on_message(model=Answer)
async def handle_answer(ctx: Context, sender: str, msg: Answer):
    print(" Answer from Gemini:", msg.answer)
    asyncio.create_task(shutdown_loop())

async def shutdown_loop():
    await asyncio.sleep(1)
    loop = asyncio.get_event_loop()
    loop.stop()

Running the Agents

Define a helper function to run the agents:

def run_agent(agent):
    agent.run()

if __name__ == "__main__":
    p = multiprocessing.Process(target=run_agent, args=(ai_agent,))
    p.start()
    time.sleep(2)  
    client_agent.run()
    p.join()

Conclusion

This tutorial provides a comprehensive guide to creating modular AI services using UAgents and Google Gemini. You have learned how to manage agent lifecycles, handle messaging, and implement a scalable architecture for AI applications.

For further exploration, consider expanding your UAgents setup to include more complex workflows and dynamic agent discovery.

All credit for this research goes to the researchers of this project. Feel free to follow us on Twitter and subscribe to our newsletter.