Build a Powerful AI Agent Pipeline: A Step-by-Step Guide Using Google ADK and Nebius AI Studio

Want to build intelligent agents that can analyze trends and automate complex tasks? This guide shows you how to create a multi-agent system using Google's Agent Development Kit (ADK) and leverage powerful LLMs like Meta Llama and Nemotron-Ultra from Nebius AI Studio.

Why Google ADK for Building AI Agents?

Google's Agent Development Kit (ADK) offers a flexible and modular framework for building real-world AI agents. It's designed to make agent development feel more like traditional software development, allowing you to:

Create: Define agent behaviors and capabilities.
Deploy: Easily integrate your agents into various environments.
Orchestrate: Manage and coordinate complex agent workflows.

This setup is lightweight and surprisingly fast, making it ideal for stitching together tools, models, and APIs into production-grade agent workflows.

Assembling Your AI Dream Team: Tools & LLMs

Our multi-agent system will leverage a suite of specialized tools and large language models (LLMs) to perform in-depth AI trend analysis.

Nebius AI Studio: This platform provides inference-as-a-service, offering a wide range of open-source models like Llama 3.1 and Nemotron-Ultra, along with flexible pricing and scalable infrastructure.
Meta Llama 3.1: A versatile LLM well-suited for multilingual dialogue, text generation, summarization, and question-answering. Explore its different sizes (8B, 70B, and 405B parameters) to find the best fit for your needs. It also has function/tool calling capabilities which are suitable for agentic use cases.
Nemotron Ultra 253B v1: NVIDIA's powerhouse LLM is fine-tuned for advanced reasoning, complex math, and tool integration. With a context length of up to 128K tokens, it's ideal for applications requiring in-depth analysis.
Tavily: A search engine optimized for LLMs, Tavily provides real-time, accurate, and unbiased web information through a single API call, simplifying the integration of dynamic data into your AI solutions.
Firecrawl: This tool transforms entire websites into LLM-ready data formats like markdown or JSON, allowing you to easily extract and utilize website content in your AI workflows. Firecrawl integrates with various SDKs and frameworks, including Python, Node.js, LangChain, and LlamaIndex, facilitating seamless usage into AI workflows.
Exa: Exa is a neural search engine tailored for AI applications using AI language processing to return relevant web content. It offers semantic and keyword search capabilities for precise information retrieval.

Understanding Agent-to-Agent (A2A) Protocol & ADK

Google's Agent-to-Agent (A2A) Protocol enables seamless communication and collaboration between AI agents, regardless of their underlying frameworks or vendors. By using standardized metadata (Agent Cards) and structured messaging, A2A allows agents to discover each other's capabilities, coordinate tasks, and securely exchange information.

Building a Sequential Agent Workflow for AI Trend Analysis

In this guide, we'll create a sequential agent workflow to analyze AI trends. Each agent will perform a specific task in a defined sequence, allowing for a focused and maintainable system.

Here’s the workflow of our AI Trend Analyzer app:

ExaAgent: Uses Exa to fetch the latest AI news and advancements from Twitter/X.
TavilyAgent: Uses Tavily to retrieve AI benchmarks, statistics, and analysis from artificialanalysis.ai.
SummaryAgent: Combines and summarizes the findings from 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 recommended relevant AI models.

Code Implementation: Step-by-Step

Let's dive into the code! We recommend using Google Colab for this tutorial as it simplifies the setup process.

1. Install Required Packages:

Run the following command in your Colab notebook to install the necessary packages and SDKs, including the Google Agent Development Kit (ADK).

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

2. Why Use LiteLLM?

While the Google Agent Development Kit (ADK) is optimized for Vertex AI, Gemini, and the Google ecosystem, it also allows using Cloud, Open, and Proprietary LLMs through LiteLLM. LiteLLM acts as a translation layer, providing a standardized OpenAI-compatible interface to over 100 LLMs from various providers, including OpenAI, Anthropic, and Nebius AI Studio.

3. Get Your API Keys:

Before moving to the next step, create accounts on all the tools mentioned above (Nebius AI Studio, Exa, Tavily, Firecrawl) and obtain your API keys.

4. Import Required 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

5. Set Up API Keys:

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

6. LLM Model Setup Using Nebius AI Studio with LiteLLM:

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")
)

7. Define Tools:

Now, let's define the tools our agents will use. We'll create three tools:

A tool to perform web searches on X (formerly Twitter).
A tool to search using a single URL.
A tool to scrape content from the Nebius AI website.

# 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  # Directly access
            }
        else:
            return {
                "type": "firecrawl",
                "error": "Scraping failed."
            }
    except Exception as e:
        return {
            "type": "firecrawl",
            "error": str(e)
        }

8. Agent Definitions:

Now, let’s define our agents. We'll create five agents:

Three agents that use specific tools to perform web searches and scraping tasks.
Two agents that handle summarization and deeper analysis of the results.

# 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 markdown table to present a concise summary of these trends, focusing on specific LLMs and their providers available on Nebius AI Studio.
- Highlight context window supported by each LLM and pricing. This will help with choosing appropriate models based on specific use cases.

Prefix your response with "**🧠AnalysisAgent:**"
Generate the table and analysis at the end.
""",
    tools=[],
    output_key="ai_insights"
)

9. Create your Sequential Agent

# Create the sequential agent and pass all agents in the correct order
sequential_agent = SequentialAgent(
    name="AITrendAnalysisAgent",
    agents=[exa_agent, tavily_agent, summary_agent, firecrawl_agent, analysis_agent]
)

10. Run the Agent

# Define an in-memory session service to manage agent state
session_service = InMemorySessionService()

# Create a runner to execute the sequential agent
runner = Runner(agent=sequential_agent, session_service=session_service)

# Run the agent with a specific input
result = runner.run(inputs={"input": "Analyze the latest trends in AI."})

# Print the final output from the analysis agent
print(result["ai_insights"])

Congratulations! You've built a powerful multi-agent pipeline using Google ADK, Meta Llama, Nemotron-Ultra, and Nebius AI Studio. This system automates AI trend analysis, providing valuable insights for developers and businesses alike.

This structured approach ensures maintainability and scalability as you adapt it to analyze more extensive AI trends.