gemini-agents-toolkit

The project is an SDK for implementing Agent-Driven Development (ADD) applications. ADD is aimed to move routine code tasks to the LLM agents and concentrate on the algorithmic and fun part of the business logic implementation.

⭐ Add a star for a duck!

How It Works  •  Requirements  •  Getting Started  •  Run Examples  •  How To Contribute

🚀How It Works

gemini-agents-toolkit is an SDK that creates LLM agents and enables their integration into pipelines for modifying generated responses.

See the picture describing the process:

The roles of every component are as follows:

1. Application: Define custom functions to guide LLM executions, launch agents for task execution, and combine tasks into pipelines.
2. gemini-agents-toolkit: A tool for creating agents, executing pipelines and interacting with Gemini.
3. Vertex AI API: A Google API for interacting with Gemini models.
4. Gemini: LLM models that generate text, code, or instructions to guide agent execution.

📝Requirements

❗️ The project uses Vertex AI API to access Gemini models, which is paid Google API ❗

You can find pricing here.

Agents request text generating only, which is paid for Text Input and Text Output. Running a pipeline will produce several requests depending on the pipeline's complexity.

========

Supported Python versions: Python 3.8 to 3.12 (gcloud requirement)

🤖Getting Started

Big Picture

This project uses Gemini via Google Cloud API. To use the project you must first set up the following:

• Google Cloud account with Billing
• Allow requesting LLM models via APIs (pricing)
• Set up gcloud tool in your environment
• Set up the project

Google Cloud account with Billing

1. Go to Google AI Studio, select "Get API key" in the menu on the left. Click "Create API" key button and select Google Cloud project to associate API key with.
2. Click suggestion to "Set up Billing" near your new API key and initialize your Google Billing account.
3. [Optional] You can add a Budget for your account, which will email you when your spendings reach configured thresholds. Choose "Budgets & alerts" in the menu on the left in Billing console and follow the instruction.
4. After this step, you should be able to test your Google Cloud project set up running curl command presented under the API keys table.

Allow requesting LLM models via APIs

1. The project uses Vertex AI API to request Gemini models, Vertex AI API should be allowed in your Google cloud account. You need to allow it from the Google Cloud Vertex AI API product page.
2. [Optional] With these instructions you can limit or increase your API requests quota.

Set up gcloud tool in your environment

Follow the Google instructions to install gcloud and to initialize it.

Set up the project

1. Clone gemini-agents-toolkit repository.
2. For the development process, you probably will need other repositories from the project. You can find other packages here. Currently, the project uses this list of other repositories:

6. gemini-agents-toolkit uses several environment variables that you need to set up:

4. Now, you need to register custom Python modules to use them in examples:

export PYTHONPATH=/my/custom/module/path:$PYTHONPATH

Modules you need to register:

❗ To have your variables set up permanently, register them in .bashrc (.zshrc etc, depending on your operational system and shell).

🎉Run Examples

Now it's time for fun!

Run examples/simple_example.py with

python examples/simple_example.py

In this example, you have created a custom function and gave Gemini ability to use your function:

import vertexai
from config import (PROJECT_ID, REGION, SIMPLE_MODEL)
from gemini_agents_toolkit import agent


def say_to_duck(say: str):
    """say something to a duck"""
    return f"duck answer is: duck duck {say} duck duck duck"


vertexai.init(project=PROJECT_ID, location=REGION)

all_functions = [say_to_duck]
duck_comms_agent = agent.create_agent_from_functions_list(functions=all_functions,
                                                          model_name=SIMPLE_MODEL)

print(duck_comms_agent.send_message("say to the duck message: I am hungry"))

=>>>><<<<=

You can create several agents, which will delegate functions execution to each other:

python examples/multi_agent_example.py

import datetime
import vertexai
from config import (PROJECT_ID, REGION, SIMPLE_MODEL, DEFAULT_MODEL)
from gemini_agents_toolkit import agent
from gemini_agents_toolkit.history_utils import summarize

vertexai.init(project=PROJECT_ID, location=REGION)


def generate_duck_comms_agent():
    """create an agent to say to a duck"""

    def say_to_duck(say: str):
        """say something to a duck"""
        return f"duck answer is: duck duck {say} duck duck duck"

    return agent.create_agent_from_functions_list(
        functions=[say_to_duck],
        delegation_function_prompt=("""Agent can communicat to ducks and can say something to them.
                                    And provides the answer from the duck."""),
        model_name=DEFAULT_MODEL)


def generate_time_checker_agent():
    """create an agent to get the time"""

    def get_local_time():
        """get the current local time"""
        return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    return agent.create_agent_from_functions_list(
        functions=[get_local_time],
        delegation_function_prompt="Agent can provide the current local time.",
        model_name=SIMPLE_MODEL)


duck_comms_agent = generate_duck_comms_agent()
time_checker_agent = generate_time_checker_agent()

main_agent = agent.create_agent_from_functions_list(
    delegates=[time_checker_agent, duck_comms_agent],
    model_name=SIMPLE_MODEL)

result_say_operation, history_say_operation = main_agent.send_message("say to the duck message: I am hungry")
result_time_operation, history_time_operation = main_agent.send_message("can you tell me what time it is?")

print(result_say_operation)
print(result_time_operation)
print(summarize(agent=main_agent, history=history_say_operation + history_time_operation))

=>>>><<<<=

You can execute your code periodicaly:

python examples/simple_scheduler_example.py

import time
import vertexai
from config import (PROJECT_ID, REGION, SIMPLE_MODEL)
from gemini_agents_toolkit import agent


def say_to_duck(say: str):
    """say something to a duck"""
    return f"duck answer is: duck duck {say} duck duck duck"


def print_msg_from_agent(msg: str):
    """print message in console"""
    print(msg)


vertexai.init(project=PROJECT_ID, location=REGION)

all_functions = [say_to_duck]
duck_comms_agent = agent.create_agent_from_functions_list(functions=all_functions,
                                                          model_name=SIMPLE_MODEL,
                                                          add_scheduling_functions=True,
                                                          on_message=print_msg_from_agent)

# no need to print result directly since we passed to agent on_message
duck_comms_agent.send_message("can you be saying, each minute, to the duck that I am hungry")

# wait 3 min to see results
time.sleep(180)

Find more advanced examples in the examples directory.

💡How To Contribute

If you want to be a code contributor

• Just pick up a task from the Issues in this repository, assign it to you and raise a pull request with proposed changes.
• If you need help, join the Discord and ask for help. The contributors team will be happy to see you!

If you want to contribute ideas or participate discussions

Feel free to join our Discord, where you can discuss the project with the contributors and probably impact on the way the project evolves.

Back to top