Build a Powerful AI Team: A Step-by-Step Guide to Google ADK and Multi-Agent Systems

Want to create a team of AI agents that can analyze trends and automate tasks? This guide shows you how to build a sequential agent pipeline using Google's Agent Development Kit (ADK) and cutting-edge LLMs. Learn how to integrate tools like Tavily, Exa, and Firecrawl with powerful models like Meta Llama and Nemotron Ultra for a surprisingly fast and efficient workflow.

Unlock the Power of Google's Agent Development Kit (ADK)

Google's ADK is a flexible framework for building real-world AI agents. Designed for creating scalable agent workflows, the ADK allows developers to create, deploy, and orchestrate agent workflows. The ADK is model-agnostic and plays well with third-party tools.

Benefits of Using ADK:

Modular architecture: Gain fine-grained control over agent behavior.
Model flexibility: Integrate with Gemini through Vertex AI, or other LLMs via LiteLLM.
Easy Integration: Access a rich set of tools and connectors for seamless system integration.

Tools for Your AI Agent Team

A powerful agent team requires specialized tools:

Nebius AI Studio: An efficient platform for deploying and scaling AI applications including the deployment of open-source LLMs like Llama 3.1 and Nemotron Ultra 253B.
Meta Llama 3.1: Meta's LLM is optimized for multilingual dialogue and tasks like text generation and summarization, with comprehensive tool-calling capabilities.
Nemotron Ultra 253B v1: NVIDIA's LLM excels in advanced reasoning, human chat, RAG, and tool calling tasks. It is suited for applications needing complex reasoning and tool integration.
Tavily: A search engine optimized for LLMs; simplifies integrating web information into AI solutions by handling searching, scraping, and content extraction.
Firecrawl: Transforms entire websites into LLM-ready data formats, like clean markdown; it offers features like scraping and data extraction.
Exa: A neural search engine tailored for AI applications that utilizes advanced AI language processing to return the most relevant web content.

Agent-to-Agent (A2A) Protocol and ADK: A Powerful Combination

Google's A2A protocol enables seamless communication between AI agents, regardless of vendor. By utilizing standardized metadata, A2A allows agents to discover capabilities, coordinate tasks, and exchange information. A2A and ADK allow developers to build robust, interoperable, and scalable AI agent ecosystems.

Building a Sequential Agent Workflow for AI Trend Analysis

Let's build an ADK sequential agent app to analyze AI trends using Nebius-hosted LLMs:

ExaAgent: Retrieves the latest AI news from X using Exa.
TavilyAgent: Retrieves AI benchmarks and statistics from artificialanalysis.ai using Tavily.
SummaryAgent: Combines and summarizes findings from the ExaAgent and TavilyAgent.
FirecrawlAgent: Scrapes content from the Nebius AI Studio homepage using Firecrawl.
AnalysisAgent: Analyzes all gathered information, including Nebius AI Studio offerings, to identify trends and recommend relevant AI models.

This modular approach provides a focused, maintainable system for AI trend analysis.

Step-by-Step Implementation of Your Multi-Agent App

Let's walk through the implementation of this app, using Google Colab.

Install Necessary Packages

Install the required packages and SDKs, including the Google Agent Development Kit (ADK):

!pip install -q google-adk litellm python-dotenv exa-py tavily-python firecrawl-py

Why LiteLLM?

The Google Agent Development Kit relies on Vertex AI and Google's ecosystem while allowing you to use Cloud, Open, & Proprietary LLMs through LiteLLM. LiteLLM serves as a translation layer with a standardized interface to 100+ LLMs. This allows access to diverse models without being confined to a single provider.

Import Libraries

# Import necessary libraries for Google ADK, LLMs, and data processing
from google.adk.models.lite_llm import LiteLlm
from google.adk.agents.llm_agent import LlmAgent
from google.adk.agents.sequential_agent import SequentialAgent
from google.adk.sessions import InMemorySessionService
from google.adk.runners import Runner

# Import libraries for data retrieval and web scraping
from exa_py import Exa
from tavily import TavilyClient
from firecrawl import FirecrawlApp

# Import standard libraries for system operations and time handling
import os
from datetime import datetime, timedelta
from google.genai import types

Set Up API Keys

Remember to get API keys for each of the tools and set them as environment variables:

os.environ["NEBIUS_API_BASE"] = "https://api.studio.nebius.ai/v1"
os.environ["NEBIUS_API_KEY"] = "your-api-key"
os.environ["EXA_API_KEY"] = "your-api-key"
os.environ["TAVILY_API_KEY"] = "your-api-key"
os.environ["FIRECRAWL_API_KEY"] = "your-api-key"

LLM Model Setup Using Nebius AI Studio with LiteLLM

Configure the LLM model using LiteLLM and Nebius AI Studio:

nebius_model = LiteLlm(
    model="openai/meta-llama/Meta-Llama-3.1-8B-Instruct",
    api_base=os.getenv("NEBIUS_API_BASE"),
    api_key=os.getenv("NEBIUS_API_KEY")
)

Tool Definitions (Exa + Tavily + Firecrawl)

Define the tools that your agents will use:

# Tool 1: Define a function to search for AI-related news using Exa on X
def exa_search_ai(_: str) -> dict:
    results = Exa(api_key=os.getenv("EXA_API_KEY")).search_and_contents(
        query="Latest AI news OR new LLM models OR AI/Agents advancements",
        include_domains=["twitter.com", "x.com"],
        num_results=10,
        text=True,
        type="auto",
        highlights={"highlights_per_url": 2, "num_sentences": 3},
        start_published_date=(datetime.now() - timedelta(days=30)).isoformat()
    )
    return {"type": "exa", "results": [r.__dict__ for r in results.results]}

# Tool 2: Define a function to search artificialanalysis.ai using Tavily
def tavily_search_ai_analysis(_: str) -> dict:
    client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
    response = client.search(
        query="AI benchmarks OR AI/LLM statistics OR AI providers analysis",
        search_depth="advanced",
        time_range="week",
        include_domains=["artificialanalysis.ai"]
    )
    return {"type": "tavily", "results": response.get("results", [])}

# Tool 3: Define a function to Scrape content of Nebius AI using Firecrawl
def firecrawl_scrape_nebius(_: str) -> dict:
    firecrawl = FirecrawlApp(api_key=os.getenv("FIRECRAWL_API_KEY"))
    try:
        scrape_result = firecrawl.scrape_url(
            url="https://studio.nebius.com/",
            formats=["markdown"],
            only_main_content=True
        )
        if scrape_result.success:
            return {
                "type": "firecrawl",
                "markdown": scrape_result.markdown
            }
        else:
            return {
                "type": "firecrawl",
                "error": "Scraping failed."
            }
    except Exception as e:
        return {
            "type": "firecrawl",
            "error": str(e)
        }

Agent Definitions

Create the AI agents and assign tools:

# Agent 1: Define the Exa agent to fetch latest AI updates from X
exa_agent = LlmAgent(
    name="ExaAgent",
    model=nebius_model,
    description="Fetches latest AI news, LLMs, and advancements using Exa.",
    instruction="""
Use the exa_search_ai tool to fetch the latest information about AI, new LLMs, and advancements in the field from Twitter and X.
Prefix your response with " **🔥ExaAgent:** "
""",
    tools=[exa_search_ai],
    output_key="exa_news"
)

# Agent 2: Define the Tavily agent to fetch AI benchmarks and related infos
tavily_agent = LlmAgent(
    name="TavilyAgent",
    model=nebius_model,
    description="Fetches AI benchmarks, statistics, and analysis using Tavily.",
    instruction="""
Use the tavily_search_ai_analysis tool to retrieve benchmarks, statistics, llm providers and relevant analysis on AI.
Prefix your response with " **🐳TavilyAgent:** "
""",
    tools=[tavily_search_ai_analysis],
    output_key="tavily_news"
)

# Agent 3: Define the Summary agent to combine and format results from Exa and Tavily Agent
summary_agent = LlmAgent(
    name="SummaryAgent",
    model=nebius_model,
    description="Summarizes and formats Exa and Tavily results.",
    instruction="""
You are a summarizer and formatter.
- Combine the information from 'exa_results' and 'tavily_results'.
- Use markdown, bullet points, emojis (🚀, 📊, 📈).
- Prefix with " **🍥SummaryAgent:** "
""",
    tools=[],
    output_key="final_summary"
)

# Agent 4: Define the Firecrawl scrapper agent to scrape content of Nebius AI Studio
firecrawl_agent = LlmAgent(
    name="FirecrawlAgent",
    model=nebius_model,
    description="Scrapes Nebius Studio homepage using Firecrawl.",
    instruction="""
Use the firecrawl_scrape_nebius tool to fetch markdown content from Nebius Studio website in proper format.
Prefix your response with " **🔥FirecrawlAgent:** "
""",
    tools=[firecrawl_scrape_nebius],
    output_key="firecrawl_content"
)

# Agent 5: Define the Analysis agent to analyze the summary and provide insights and also consider Nebius Scrapped data
analysis_agent = LlmAgent(
    name="AnalysisAgent",
    model=LiteLlm(
        model="openai/nvidia/Llama-3_1-Nemotron-Ultra-253B-v1",
        api_base=os.getenv("NEBIUS_API_BASE"),
        api_key=os.getenv("NEBIUS_API_KEY")
    ),
    instruction="""
You are an AI analyst specializing in the latest AI trends and Large Language Models (LLMs).
- Analyze the 'final_summary', combining it with your knowledge of AI advancements and the information extracted from 'exa_results' and 'tavily_results'.
- Identify key trends, growth areas, and notable statistics related to AI and LLMs.
- Carefully examine the 'firecrawl_content', which contain data from Nebius AI Studio. This file provides details about available models on Nebius, including their names, pricing, token limits, and availability.
- Instead of focusing solely on model names, analyze the functional capabilities and intended use cases of LLMs mentioned in the 'final_summary'.
- Cross-reference the LLMs' functionalities with the Nebius AI Studio offerings in 'firecrawl_content', prioritizing models with similar features such as context window size, training data, or specialized capabilities.
- Utilize a clear and concise format, such as a Markdown table, to showcase the identified trends and Nebius AI Studio LLM capabilities.
- Finally, the output should be prefixed with " **📈AnalysisAgent:** "
""",
    tools=[],
    output_key="llm_trends"
)

For the AnalysisAgent, we switch to nvidia/Llama-3_1-Nemotron-Ultra-253B-v1 for deeper insights using its advanced analysis capabilities.

You've now built a sequential agent pipeline that leverages Google ADK, LiteLLM, and a suite of powerful tools and LLMs to analyze AI trends effectively.