Equipo de Investigación Multi-Agente con Google ADK, Tavily y Crawl4AI

User Query
    │
    ▼
┌─────────────────────┐
│  Coordinator Agent   │  ← LLM decides routing
│  (gemini-flash-latest)│
└──────┬──┬──┬────────┘
       │  │  │
       ▼  ▼  ▼
   ┌───────┐ ┌──────────┐ ┌───────────┐
   │Search │ │Extractor │ │Summarizer │
   │Agent  │ │Agent     │ │Agent      │
   └───┬───┘ └────┬─────┘ └─────┬─────┘
       │          │              │
       ▼          ▼              ▼
   Tavily API  Crawl4AI     LLM reasoning
       │          │              │
       └──────────┴──────────────┘
                   │
            Session State
            (shared memory)
                   │
                   ▼
            Final Response

# Create project directory
mkdir adk-research-team
cd adk-research-team

# Initialize with uv
uv init
uv venv

# Install required packages
uv add google-adk langchain-tavily python-dotenv crawl4ai

# .env file
GOOGLE_API_KEY=your_google_ai_studio_api_key
TAVILY_API_KEY=your_tavily_api_key
# Optional: force the non-enterprise Gemini API path
GOOGLE_GENAI_USE_ENTERPRISE=False

adk-research-team/
├── .env                       # API keys
└── agent_module/              # Agent package
    ├── __init__.py            # Makes it a Python package
    ├── agent.py               # Main file with root_agent
    ├── search_agent.py        # Search specialist
    ├── content_extractor.py   # Content analysis specialist
    └── summarizer.py          # Summarization specialist

mkdir -p agent_module
touch agent_module/__init__.py

# This file makes agent_module a proper Python package
# The import below ensures that agent.py is accessible
from . import agent

touch agent_module/search_agent.py

from dotenv import load_dotenv
import os
from google.adk.agents import LlmAgent
from google.adk.integrations.langchain import LangchainTool
from langchain_tavily import TavilySearch

load_dotenv()


def create_search_agent():
    """
    Creates an agent specialized in web searching using Tavily Search.
    """
    if not os.getenv("TAVILY_API_KEY"):
        raise ValueError("TAVILY_API_KEY not found in environment variables")

    # Create Tavily Search tool (langchain-tavily package)
    tavily_tool = TavilySearch(
        max_results=5,
        topic="general",
        search_depth="advanced",
        include_answer=True,
        include_raw_content=True,
        include_images=False,
    )

    # Wrap for ADK
    adk_tavily_tool = LangchainTool(tool=tavily_tool)

    return LlmAgent(
        name="search_agent",
        model="gemini-flash-latest",
        description="A specialized agent that searches the web for information using Tavily Search API.",
        instruction="""You are a web research specialist.

        When asked to find information about a topic, craft an effective search query and use the TavilySearch tool.

        After receiving search results:
        1. Parse the response which may contain a direct answer and multiple search results.
        2. Format the results in a clear, structured way, with each result showing the title, link, and a brief preview of the content.
        3. Highlight the most relevant results based on the original query.
        4. If Tavily provided a direct answer, present that first as the most likely answer.

        If the search doesn't return useful results, suggest refined search terms for a follow-up search.

        Avoid making up information - only report what is found in the search results.
        """,
        tools=[adk_tavily_tool],
    )

touch agent_module/content_extractor.py

from dotenv import load_dotenv
import asyncio
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig
from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from google.adk.tools.tool_context import ToolContext

load_dotenv()


async def extract_content_from_url(url: str, tool_context: ToolContext = None) -> dict:
    """
    Extracts content from a URL using Crawl4AI.

    Args:
        url (str): The URL to extract content from.
        tool_context (ToolContext, optional): Tool context for ADK session state.

    Returns:
        dict: Extracted content, metadata, and status.
    """
    async with AsyncWebCrawler() as crawler:
        result = await crawler.arun(url=url, config=CrawlerRunConfig())

    # Crawl4AI 0.9.x: result.markdown is a MarkdownGenerationResult object
    md = result.markdown.raw_markdown if result.markdown else ""

    # Title: try metadata first, fall back to first markdown heading
    title = (result.metadata or {}).get("title")
    if not title and md:
        for line in md.split("\n"):
            if line.startswith("# "):
                title = line[2:]
                break

    response = {
        "status": "success" if result.success else "error",
        "title": title,
        "url": result.url or url,
        "markdown_content": md[:10000],  # Limit to 10k chars for context window
        "content_length": len(md),
        "word_count": len(md.split()),
        "has_truncated_content": len(md) > 10000,
        "error_message": result.error_message if not result.success else None,
    }

    # Store full content in session state for the summarizer
    if tool_context and md:
        tool_context.state["temp:extracted_content"] = md

    return response


def create_content_extractor_agent():
    """
    Creates an agent specialized in extracting and analyzing content from URLs.
    """
    extract_tool = FunctionTool(func=extract_content_from_url)

    return LlmAgent(
        name="content_extractor",
        model="gemini-flash-latest",
        description="A specialized agent that extracts and analyzes content from web pages using Crawl4AI.",
        instruction="""You are a web content analysis specialist.

        When given a URL, use the extract_content_from_url tool to fetch and analyze its content.

        After extracting content:
        1. Report the page title and basic metadata (word count, if content was truncated).
        2. Highlight key information found in the content that's most relevant to the user's request.
        3. Note if there were any errors during extraction.

        When extracting content from multiple URLs, organize the information clearly by URL.

        If the extraction fails, explain the error and suggest possible solutions.
        """,
        tools=[extract_tool],
    )

touch agent_module/summarizer.py

from google.adk.agents import LlmAgent


def create_summarizer_agent():
    """
    Creates an agent specialized in summarizing content.
    Uses output_key to automatically save the summary to session state.
    """
    return LlmAgent(
        name="summarizer",
        model="gemini-flash-latest",
        description="A specialized agent that summarizes content at various detail levels.",
        instruction="""You are a professional content summarizer.

        Summarize the content provided to you according to the requested length:

        - "short": A concise summary in 1-3 sentences, capturing only the essential point.
        - "medium": A balanced summary in 1-3 paragraphs, covering key points and some supporting details.
        - "long": A comprehensive summary in multiple paragraphs, preserving nuances and important contexts.

        If no length is specified, default to "medium".

        Always structure summaries with clear headings and bullet points when appropriate.

        Prioritize accuracy over brevity - never include information not found in the original text.

        For technical or complex content, preserve the key terminology used in the original text.
        """,
        output_key="summary",
    )

touch agent_module/agent.py

from google.adk.agents import LlmAgent

# Import our specialized agents
from agent_module.search_agent import create_search_agent
from agent_module.content_extractor import create_content_extractor_agent
from agent_module.summarizer import create_summarizer_agent

# Define the root agent that ADK web will use
root_agent = LlmAgent(
    name="research_coordinator",
    model="gemini-flash-latest",
    description="A coordinator agent that manages a team of specialized research agents.",
    instruction="""You are the coordinator of a research assistant team with specialized agents.

    Your team includes:
    - search_agent: Finds information on the web using Tavily Search.
    - content_extractor: Analyzes and extracts content from specific URLs.
    - summarizer: Creates concise summaries of content at different levels of detail.

    Based on user requests, delegate tasks to the appropriate specialist:

    1. If the user needs to find information on a topic, delegate to search_agent.
    2. If the user provides a specific URL or wants to analyze a web page, delegate to content_extractor.
    3. If the user needs a summary of content, delegate to summarizer.
    4. For complex research tasks, coordinate multiple agents in sequence:
       - First search for relevant information
       - Then extract detailed content from the most promising URLs
       - Finally summarize the findings

    Always present the results from your specialists in a clear, organized manner.
    When coordinating multi-step research, explain the research process to the user.

    Remember: You are responsible for the final response to the user, so ensure it fully addresses their request.
    """,
    sub_agents=[
        create_search_agent(),
        create_content_extractor_agent(),
        create_summarizer_agent(),
    ],
)

# From the project root (where .env is located)
adk web

# Test the search agent standalone
adk run agent_module/search_agent.py

adk api_server

# Health check
curl http://127.0.0.1:8000/health

# List available agents
curl http://127.0.0.1:8000/list-apps